Cross-platform hardware benchmark of style-based quantum GANs for data augmentation on superconducting and trapped-ion processors

This paper presents a cross-platform benchmark comparing the performance of a fixed style-based quantum GAN for high-energy physics data augmentation on IBM's superconducting ibm_torino and IonQ's trapped-ion aria-1 processors, revealing that while IonQ achieved slightly better statistical quality, IBM's platform offered significantly faster end-to-end runtime.

The Gist

Imagine you are trying to teach a robot chef to recreate a very specific, complex recipe (like a rare dish from a high-end restaurant). You have a small sample of the real dish, and you want the robot to learn how to cook it so well that it can make thousands of perfect copies. This is the job of a Quantum GAN (Generative Adversarial Network). Think of it as a game between two robots:

• The Chef (Generator): Tries to cook a fake dish that looks real.
• The Critic (Discriminator): Tries to spot the difference between the fake dish and the real one.

They play this game over and over until the Chef gets so good that the Critic can't tell the difference anymore.

This paper is a "race" to see which type of quantum computer hardware is better at helping the Chef learn this recipe. The researchers didn't invent a new recipe; they took an existing one and tested it on two very different types of "kitchens."

The Two Competing Kitchens

The paper compares two commercially available quantum computers, which are like two different types of kitchens with very different tools and speeds:

1. The IBM Kitchen (Superconducting):

   • The Tool: Uses tiny superconducting circuits (like super-fast, super-cold electrical loops).
   • The Vibe: It's a Formula 1 car. It is incredibly fast. The "gates" (the steps the computer takes) happen in microseconds. It can process a huge amount of data very quickly.
   • The Flaw: It's a bit "noisy." The ingredients (qubits) are a little bit jumpy, and when the computer reads the final result (the dish), it makes more mistakes (readout errors) than the other kitchen.

2. The IonQ Kitchen (Trapped Ions):

   • The Tool: Uses individual atoms (ions) held in place by lasers.
   • The Vibe: It's a precision Swiss watch. It is much slower. The steps take longer to perform. However, the ingredients are very stable, and the final reading is extremely accurate with very few mistakes.
   • The Flaw: It's slow. If you need to cook a million dishes, it takes a long time because every single step is deliberate and slow.

The Experiment: "Data Augmentation"

The goal wasn't just to see who was faster, but to see who could make the best "fake" data to help scientists. In this case, the data was about particle physics (specifically, collisions of protons at the Large Hadron Collider).

The researchers took a trained "Chef" (the quantum algorithm) and sent it to both kitchens. They kept the recipe exactly the same and turned off any "noise-canceling" software to see how the raw hardware performed.

To make the race fair and efficient, they used a trick called Circuit Replication.

• Analogy: Imagine you have a small stamp. Instead of stamping a piece of paper 100 times one by one, you tape 16 stamps together and press them down once. You get 16 stamps at once.
• The researchers did this with the quantum circuits. They ran the recipe on 16 sets of qubits at once on the IBM machine and 8 sets on the IonQ machine. This meant they had to send fewer "orders" to the computers to get the same amount of results.

The Results: Speed vs. Accuracy

Here is what happened when they compared the two kitchens:

1. The Taste Test (Accuracy):

• The Winner: The IonQ (Trapped Ion) kitchen.
• Why: The "fake" dishes it produced were closer to the real recipe. The math showed that the IonQ machine made fewer errors in the final taste.
• The Reason: The IonQ machine is much more precise when it reads the final result. It's like a chef who has a very steady hand and a perfect palate, even if they cook slowly.

2. The Stopwatch (Speed):

• The Winner: The IBM (Superconducting) kitchen.
• Why: It finished the entire task in about 6 hours and 43 minutes. The IonQ machine took nearly 60 hours (almost 2.5 days) to do the exact same job.
• The Reason: The IBM machine is just lightning fast. Even though it made a few more mistakes, it could churn through the work so quickly that it finished the whole project in a fraction of the time.

The Bottom Line

The paper concludes that there is no single "best" computer; it depends on what you value:

• If you need the most accurate result and can wait a long time, the IonQ (Trapped Ion) machine is better.
• If you need the result quickly and can tolerate a tiny bit more error, the IBM (Superconducting) machine is the clear winner.

The authors emphasize that this is a practical test of current hardware. They aren't saying one technology is "better" for the future of the universe, but rather that for this specific task (making fake particle physics data), you have to choose between speed (IBM) and precision (IonQ).

Key Takeaway: The paper doesn't claim this will cure diseases or solve climate change right now. It simply says: "If you are a scientist trying to generate data using quantum computers today, here is the trade-off you will face between these two specific machines."

Technical Summary

Technical Summary: Cross-platform Benchmark of Style-based qGANs for Data Augmentation

Problem Statement
In the Noisy Intermediate-Scale Quantum (NISQ) era, there is a critical need for controlled benchmarks of quantum machine learning (QML) workloads across different hardware modalities. While algorithmic advancements continue, the performance of specific algorithms under native provider execution stacks remains heterogeneous due to differences in connectivity, gate speeds, fidelity, and software stacks. Specifically, while style-based quantum Generative Adversarial Networks (qGANs) have shown promise for data augmentation tasks—particularly in generating non-Gaussian distributions for high-energy physics (HEP)—previous demonstrations were largely confined to single hardware platforms (e.g., IBM superconducting systems) or lacked rigorous cross-platform comparison. This work addresses the gap by quantitatively assessing whether a fixed style-based qGAN generator can perform effective data augmentation on two distinct hardware architectures: superconducting transmon qubits and trapped-ion qubits.

Methodology
The study implements a controlled cross-platform benchmark using a fixed style-based qGAN workflow trained on a dataset of $10^4$ Monte Carlo events for top-antitop quark production ($pp \to t\bar{t}$) at the Large Hadron Collider (LHC). The goal is to generate $10^5$ synthetic samples to augment the training data.

• Hardware Platforms:
  • IBM ibm torino: Based on the Heron architecture with 133 superconducting transmon qubits arranged in a heavy-hex lattice.
  • IonQ aria-1: Based on trapped-ion qubits ($^{171}\text{Yb}^+$) with 25 qubits and all-to-all connectivity.
• Algorithm and Architecture:
  • The generator is a parameterized quantum circuit (PQC) with a single layer, utilizing a "style-based" approach where latent variables are re-uploaded throughout the network rather than just at the input.
  • The discriminator is a classical deep convolutional neural network.
  • Crucial Constraint: The generator architecture and trained parameters are fixed across both platforms. The model was trained previously (in Ref. [16]) and checkpoints were reused to ensure a fair comparison of hardware execution rather than retraining.
  • Circuit Replication: To improve sample throughput, the base 3-qubit circuit was replicated $m$ times within a single job submission.
    • On ibm torino: 16 replications using 48 qubits ($m=16$).
    • On aria-1: 8 replications using 24 qubits ($m=8$).
    • This strategy reduced the number of required job submissions from $10^5$ to $6,250$ (IBM) and $12,500$ (IonQ) to generate the target sample set.
• Experimental Conditions:
  • Native Execution: Built-in error mitigation (e.g., debiasing) was deliberately disabled to compare "bare" hardware performance.
  • Shot Budgets: IBM used the nominal 4,000 shots per circuit; IonQ used 512 shots per circuit, determined via noise simulation to balance wall-clock time and statistical quality.
  • Metrics: Quality was measured using Kullback-Leibler (KL) divergence between generated and reference distributions for physical observables ($s, t, y$). Runtime metrics included end-to-end wall-clock time, per-circuit time, and per-shot time.

Key Results
Both platforms successfully completed the data augmentation task, producing distributions with low KL divergences, though with distinct trade-offs in quality and speed.

• Quality (KL Divergence):

  • IonQ aria-1 achieved lower (better) marginal KL divergences: $0.25$($s$),$0.14$($t$), and $0.07$($y$).
  • IBM ibm torino showed slightly higher divergences: $0.51$($s$),$0.31$($t$), and $0.44$($y$).
  • The authors attribute the superior accuracy on IonQ primarily to its significantly lower readout error rate (approx. $5.1 \times 10^{-3}$ vs. $2.7 \times 10^{-2}$ on IBM) and all-to-all connectivity, which reduces the need for SWAP gates and accumulated errors in shallow circuits.
  • Uncertainty analysis (via sample variance propagation) indicates the performance gap is narrower than nominal values suggest, but IonQ remains more accurate in this specific unmitigated setup.

• Runtime and Throughput:

  • IBM ibm torino was significantly faster, completing the full $10^5$ sample generation in approximately 6 hours, 43 minutes.
  • IonQ aria-1 required approximately 59 hours, 57 minutes for the same task.
  • The speed advantage of IBM is driven by the orders-of-magnitude faster gate and readout times of superconducting transmons compared to trapped ions, as well as the ability to batch multiple circuits per job.
  • Per-circuit execution time (including transpilation) was roughly 1 ms on IBM versus 34 ms on IonQ.

Significance and Claims
The paper positions this work not as a claim of algorithmic novelty, but as a practical, application-specific tradeoff benchmark.

1. First Controlled Comparison: To the authors' knowledge, this is one of the first controlled hardware-to-hardware comparisons of style-based qGANs for HEP data augmentation.
2. Hardware Trade-offs: The results highlight a clear trade-off:
   • Trapped-ion systems (IonQ) offer higher fidelity for shallow variational circuits in unmitigated settings, likely due to better readout fidelity and connectivity, making them suitable for applications prioritizing distributional accuracy over speed.
   • Superconducting systems (IBM) offer significantly faster turnaround and higher throughput, making them preferable for applications where sample volume and speed are critical, potentially offsetting lower fidelity with mitigation techniques or larger sample sizes.
3. Practical Implementation: The study demonstrates that circuit replication is an effective strategy for scaling sample throughput on current NISQ devices without retraining the model.
4. Limitations: The authors explicitly state that the conclusions are workload-specific. The benchmark is limited by performing only one run per platform, differing shot counts, and the exclusion of user-level error mitigation. They note that applying readout mitigation on IBM could narrow the accuracy gap, and future hardware improvements (faster gates for IonQ, better readout for IBM) will shift these benchmarks.

In summary, the paper provides a quantitative baseline for how a fixed quantum generative model behaves on two leading quantum hardware modalities, demonstrating that both can perform useful data augmentation but with distinct operational profiles regarding accuracy and execution time.