⚛️ quantum physics

SQGen: Structured Quantum Image Generation with Latent-Modulated Quantized Tensor Trains

SQGen is a fully quantum image generator that leverages latent-modulated quantized tensor trains to enable stable training and end-to-end image generation on NISQ hardware without requiring a classical decoder.

Original authors: Guang Lin, Qibin Zhao

Published 2026-07-08

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Guang Lin, Qibin Zhao

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 want to teach a tiny, fragile robot (a quantum computer) to draw pictures. The problem is that this robot is very sensitive; if you ask it to do a long, complicated dance (a deep circuit), it gets confused and forgets everything before it finishes. Also, if you ask it to draw a whole picture at once, it gets overwhelmed.

The paper introduces SQGen, a new way to teach this robot to draw images without needing a human assistant (a classical decoder) to finish the job. Here is how it works, broken down into simple concepts:

1. The Problem: The "Fragile Robot" and the "Heavy Backpack"

Current methods for making quantum computers draw images face three big hurdles:

The "Blank Wall" (Barren Plateaus): If the robot's instructions are too long, it gets stuck. It's like trying to find a needle in a haystack where the haystack is the size of a planet; the robot can't see any direction to move.
The "Heavy Backpack" (State Preparation): Some methods try to load the whole image into the robot's memory at once. This requires a huge, heavy backpack that breaks the robot's back (the hardware) before it can even start drawing.
The "Human Crutch" (Classical Decoders): Many current solutions let the robot do a tiny bit of work and then hand the result to a human (a classical computer) to finish the picture. The paper argues this isn't a true "quantum advantage" because the human did the hard part.

2. The Solution: SQGen's Two-Part Trick

SQGen solves these problems with two main ideas, like giving the robot a special set of tools and a new way to think.

Idea A: The "Russian Nesting Doll" Structure (Quantized Tensor Train)

Instead of trying to draw the whole image at once, SQGen breaks the image down into layers, like a set of Russian nesting dolls or zooming in on a map.

How it works: It starts with a rough sketch (coarse details) and then adds finer and finer details (fine pixels) step-by-step.
The "Bond" Qubits: Imagine the robot has a small "memory stick" (ancilla qubits) that it passes between each step of the drawing. This memory stick holds the connection between the rough sketch and the fine details.
The Benefit: Because the robot only has to focus on one small layer at a time, it doesn't get overwhelmed. It's like building a house brick by brick rather than trying to lift the whole roof in one go. This keeps the instructions short enough for the fragile robot to handle.

Idea B: The "Magic Dial" (Latent Modulation)

To make the robot draw different pictures (not just the same one every time), SQGen uses a "Magic Dial" (a latent variable).

How it works: Usually, you have to reprogram the robot's entire brain to change the drawing. SQGen is smarter. It takes the robot's standard drawing instructions and adds a tiny, adjustable "knob" to the angles of its movements.
The Analogy: Think of a musician playing a song. The "main path" is the sheet music (the fixed structure of the image). The "latent term" is the musician's improvisation or the tempo they choose. By turning the dial, the robot can play the same song but with a different feel, creating variety without rewriting the whole song.
The Benefit: This allows the robot to generate many different versions of an image (like different faces of the same person) just by turning a dial, without needing a complex new setup for each one.

3. The Training Process: "Practice on Paper, Perform on Stage"

This is perhaps the most clever part of the paper.

The Rehearsal (Classical Training): The robot is too fragile to learn by trial and error on the real quantum hardware. So, the scientists build a perfect, mathematical "shadow" of the robot on a regular computer. They teach this shadow how to draw using exact math (no guessing).
The Transfer: Once the shadow is perfect, they copy the instructions one-to-one onto the real quantum robot.
The Performance (Quantum Deployment): When it's time to draw, the real robot runs the instructions. There is no human helper needed at the end. The robot measures its own qubits, and the picture appears directly.

4. The Results: Does it Work?

The authors tested SQGen on drawing numbers (like the digits 0–9) and some synthetic patterns.

Stability: The robot learned without getting stuck or confused (no "barren plateaus").
Quality: It drew clear, recognizable images that looked like the target numbers.
Variety: It could draw different versions of the same number, not just a copy-paste of one image.
Real Hardware: When they tried it on a real, noisy quantum computer (IBM's hardware), SQGen still managed to draw recognizable shapes. In contrast, a competing method (which used the "heavy backpack" approach) failed completely and produced noise.

Summary

SQGen is like teaching a fragile quantum robot to paint by:

Breaking the painting into small, manageable layers (so it doesn't get overwhelmed).
Giving it a simple dial to change the style (so it can create variety).
Letting it practice perfectly on a computer first, then copying the perfect plan to the real robot so it can perform the whole show without human help.

The paper claims this is a promising step toward making quantum computers that can generate images on their own, even on today's imperfect hardware.

Technical Summary of SQGen: Structured Quantum Image Generation with Latent-Modulated Quantized Tensor Trains

Problem Statement

Generating images directly from quantum systems on Noisy Intermediate-Scale Quantum (NISQ) hardware remains an unresolved challenge. Existing quantum generative models face three primary, coupled obstacles:

Trainability: Deep parameterized circuits often suffer from "barren plateaus," where gradient variance vanishes exponentially with qubit count and circuit depth, stalling optimization.
Circuit Complexity: Methods relying on amplitude encoding incur expensive state-preparation costs, and the deep circuits required to prepare these states erode quantum information due to hardware noise.
End-to-End Quantum Advantage: Producing image-scale outputs typically requires a classical decoder to interpret quantum states. This hybrid approach breaks the end-to-end quantum advantage, as the bulk of the modeling capacity resides in the classical component.

Current hybrid approaches (e.g., shallow quantum components with classical decoders) fail to provide a genuine quantum advantage for high-dimensional targets, while purely quantum approaches struggle with the noise and depth constraints of NISQ devices.

Methodology

The authors propose SQGen, a full quantum generator designed to operate end-to-end without a classical decoder during inference. The architecture is built on a Quantized Tensor Train (QTT) skeleton with Latent Modulation (LM), trained entirely on classical hardware and deployed as a native-gate quantum circuit.

1. QTT Bond Skeleton (Physical Implementation):

Structure: The model utilizes a QTT decomposition of the target pixel distribution. Unlike classical tensor networks, SQGen promotes the QTT bond indices to physical ancilla bond qubits.
Mechanism: For an image of size $2^{n_s} \times 2^{n_s}$ , the row and column coordinates are mapped to binary bits across $n_s$ scales. Each scale is encoded by two physical qubits. The bond dimension $\chi$ is mapped to $n_b = \log_2 \chi$ ancilla qubits.
Operation: Each circuit site applies a local unitary on the bond register (ancillas) and the two physical qubits representing a specific image scale. The output is the bond-marginal Born distribution, obtained by measuring all qubits and discarding the ancilla bits. This structure allows the circuit to learn multi-scale correlations efficiently with a limited number of qubits.

2. Latent Modulation (LM):

Angle-Level Factorization: To condition the generation on a latent variable $z$ , SQGen refines the data re-uploading technique. Instead of placing re-uploading rotations adjacent to trainable rotations, it factorizes the rotation angle into a trainable main path plus an additive latent term.
Mathematical Basis: This relies on the abelian property of rotations about a common axis. A rotation $R_a(\theta) R_a(\omega \cdot z + \beta)$ is exactly equivalent to a single rotation $R_a(\theta + \beta + \omega \cdot z)$ .
Benefit: This exact decomposition allows the latent $z$ to modulate the output angles directly. In deployment, these rotations can be fused into single native gates, reducing circuit depth.

3. Classical Training, Quantum Deployment Pipeline:

Training: The model is trained entirely on a classical system using a differentiable QTT implementation.
- Latent Prior: The latent variable $z$ is sampled from a torus prior ( $\mathbb{T}^d$ ) using a scrambled Sobol quasi-Monte Carlo sequence, matching the $2\pi$ periodicity of rotation angles.
- Encoder: A small CNN-based encoder maps images to the torus latent space during training.
- Objective: The training minimizes a reconstruction loss (KL divergence and L1 distance) between the target pixel distribution and the Born distribution of the circuit at $z = E_\phi(x)$ .
- Optimization: Exact gradients are backpropagated through the tensor contractions, avoiding the shot-noise and barren plateau issues associated with variational quantum training.
Deployment: After training, the encoder is discarded. The learned parameters are exported one-to-one to a native-gate quantum circuit (using gates $\{R_y, R_z, \text{CNOT}\}$ ). Inference involves sampling $z$ directly from the torus prior, executing the circuit, and measuring in the computational basis.

Key Contributions

SQGen Architecture: A structured quantum image generator combining a QTT bond skeleton (which learns multi-scale features efficiently using ancilla qubits) and Latent Modulation (which provides exact, angle-level conditioning to improve sample diversity).
Classical Training Pipeline: A fully classical training framework that optimizes a differentiable QTT model under a torus prior. This avoids barren plateaus and sampling overhead, enabling the export of parameters to a native-gate circuit without a classical decoder in the inference path.
Empirical Validation: Extensive experiments demonstrating that SQGen trains stably, achieves low reconstruction error (KL and L1) on MNIST and Fashion-MNIST, maintains sample diversity, and shows promising feasibility on real quantum hardware compared to amplitude-encoding baselines.

Experimental Results

Performance on MNIST: SQGen achieved the lowest per-sample KL and L1 errors across all ten digit classes while maintaining non-zero sample diversity. It outperformed ablations (Vanilla Born Machine, BM+LM, BM+QTT) and trivial baselines.
- Ablation Findings: The QTT bond skeleton alone produced a static, zero-diversity prototype. Latent modulation alone produced noisy samples with poor fidelity. Only their combination (SQGen) yielded sharp class structure with latent-conditional variation.
Synthetic Targets: On controlled tasks (multi-scale stripes and moving Gaussian blobs), SQGen successfully reproduced complex spatial patterns and demonstrated consistent variation with continuous latent inputs.
Bond Rank Scaling: Increasing the bond rank $\chi$ improved reconstruction quality up to a point (saturation at $\chi=8$ ), but higher ranks increased circuit complexity and noise sensitivity.
Noise Robustness: Under depolarizing noise simulations, SQGen showed a trade-off between representational capacity (higher $\chi$ ) and noise resilience (lower $\chi$ ).
Real Hardware: Deployed on the ibm_kawasaki device, SQGen generated images closely resembling the target, whereas an amplitude-encoding baseline suffered severe degradation and lost structural integrity.

Significance and Claims

The paper claims that SQGen addresses the fundamental barriers to quantum image generation on NISQ hardware by:

Eliminating the Classical Decoder: Achieving true end-to-end quantum generation where the output distribution is read directly from quantum measurements.
Ensuring Trainability: By training classically on a differentiable tensor network, the method bypasses the barren plateau problem inherent in deep variational quantum circuits.
Hardware Compatibility: The use of a shallow, native-gate circuit with a structured QTT topology makes the model feasible for current quantum devices, as demonstrated by the superior performance on real hardware compared to state-preparation-heavy baselines.

The authors position SQGen not as a universal solution for all quantum generative tasks, but as a specific architectural advancement that enables structured, image-scale generation with a clear path to deployment on NISQ devices.