HyQBench: A Benchmark Suite for Hybrid CV-DV Quantum Computing

This paper introduces HyQBench, a standardized simulation and benchmarking framework for hybrid continuous-variable and discrete-variable quantum computing that defines novel complexity metrics and evaluates a diverse suite of algorithms to demonstrate the viability and resource requirements of emerging hybrid hardware platforms.

The Gist

Imagine you are trying to build the ultimate supercomputer. For decades, scientists have been building these machines using tiny switches that can be either OFF (0) or ON (1). These are called Discrete-Variable (DV) systems, or "qubits." They are like a light switch: it's either up or down.

But there's another way to think about quantum computing. Instead of a light switch, imagine a dimmer switch or a volume knob. You can set it to any value in between—0.1, 0.5, 9.9. These are Continuous-Variable (CV) systems, or "qumodes." They are like a smooth, infinite slider rather than a clicky button.

The Problem: Two Great Tools, No Common Language

For a long time, researchers built computers using only light switches (DV) or only dimmer switches (CV).

• DV (Light Switches) are great at logic and control, but they struggle to simulate things that naturally flow, like sound waves or light particles. To simulate a smooth wave, you have to use thousands of light switches, which is messy and inefficient.
• CV (Dimmer Switches) are amazing at simulating smooth waves and high-dimensional data, but they are terrible at doing precise logic. They lack the "brainpower" to make complex decisions or correct their own mistakes easily.

The Hybrid Solution:
Recently, scientists started building Hybrid computers. These are like a car with both a steering wheel (the precise control of the light switch) and a powerful engine (the smooth power of the dimmer switch). They combine the best of both worlds.

The Missing Piece: The "Driver's License Test"

Here is the problem: We have these new hybrid cars, but we don't have a standard driver's license test for them.

• We know how to test regular cars (DV benchmarks).
• We know how to test motorcycles (CV benchmarks).
• But we don't have a standardized test to see if a Hybrid Car is actually good, how fast it goes, or if it's reliable.

Without a test, how do we know if a new hybrid computer is better than an old one? How do we know if the software running on it is efficient?

Enter: HyQBench (The Hybrid Car Test Drive)

This paper introduces HyQBench, a new "test drive" suite designed specifically for these Hybrid CV-DV quantum computers. Think of it as a standardized obstacle course for these new machines.

The authors created a toolbox (using software called Bosonic Qiskit and QuTiP) to simulate these hybrid circuits and measure how well they perform.

The Obstacle Course (The Benchmarks)

Just like a driving test has different challenges, HyQBench has eight specific tasks to see how the hybrid computer handles different jobs:

1. State Transfer (The Handoff): Imagine passing a delicate glass of water from a robot arm (the dimmer switch) to a human hand (the light switch) without spilling a drop. This tests how well the two systems talk to each other.
2. Cat State & GKP State (The Magic Tricks): These are like asking the computer to create a "Schrödinger's Cat" (a cat that is both alive and dead at the same time) or a very specific, grid-like pattern. These are the "magic tricks" needed to build error-correcting codes (making the computer less prone to mistakes).
3. QFT (The Translator): This is a complex math operation that translates information. The hybrid computer tries to do this by using the dimmer switch to do the heavy lifting, then handing the result back to the light switch.
4. VQE & QAOA (The Optimizers): Imagine you are a delivery driver trying to find the shortest route to 100 stops. These benchmarks test if the hybrid computer can find the best solution faster than a regular computer.
5. JCH Simulation (The Physics Lab): This simulates how light and atoms interact in a cavity. It's like simulating a tiny universe inside the computer.
6. Shor's Algorithm (The Code Breaker): The famous algorithm that can crack encryption. The hybrid version tries to do this using fewer resources than a standard computer.

How They Measure Success (The Scorecard)

The paper doesn't just say "Pass" or "Fail." They created a new scorecard with two types of metrics:

1. General Stats: How many switches and knobs did we use? How long did the circuit take? (Standard stuff).
2. Hybrid-Specific Stats:
   • Wigner Negativity: Think of this as a "Weirdness Meter." If the number is high, the computer is doing something truly quantum and "spooky" that a normal computer can't easily copy.
   • Truncation Cost: Since the dimmer switch is infinite, we have to pretend it's finite for the test. This metric checks if we cut off too much of the "infinite" part, which would ruin the accuracy.

The Results: It Works!

The team ran these tests on simulations and even on a real machine (a trapped-ion computer at Sandia National Labs called QSCOUT).

• The Good News: The hybrid approach is much more efficient. For example, to simulate a specific physics model (JCH), a standard computer needed 9 switches and hundreds of complex operations. The hybrid version did it with just 3 switches and 3 dimmer knobs. It was like solving a puzzle with fewer pieces.
• The Reality Check: The real machine test (the Cat State) worked, but it wasn't perfect yet. The "fidelity" (accuracy) was about 71%. This isn't because the idea is bad, but because the hardware is still being calibrated. It's like a new sports car that runs great but needs its engine tuned.

Why This Matters

This paper is a roadmap. It tells us:

1. Hybrid computers are viable: They aren't just a theory; they work.
2. They are efficient: They can solve problems with fewer resources than traditional methods.
3. We have a ruler: Now that we have HyQBench, researchers can stop guessing and start measuring. They can compare different hardware, fix software bugs, and know exactly how much "quantum weirdness" they are generating.

In a nutshell: We built a new type of quantum car that mixes the best of two worlds. This paper built the first standardized test track to see how fast and reliable these cars really are, proving that they have the potential to drive us into the future of computing.

Technical Summary

Here is a detailed technical summary of the paper "HyQBench: A Benchmark Suite for Hybrid CV-DV Quantum Computing."

1. Problem Statement

The field of quantum computing has historically focused on Discrete-Variable (DV) systems (qubits) or Continuous-Variable (CV) systems (qumodes/bosonic modes) in isolation.

• DV Limitations: While versatile, simulating bosonic systems (e.g., harmonic oscillators) on DV hardware requires encoding infinite-dimensional states into finite qubit registers, leading to significant overhead in gate counts and circuit depth.
• CV Limitations: Pure CV systems struggle with implementing non-Gaussian operations and achieving fault tolerance without external control.
• The Gap: Hybrid CV-DV architectures (coupling qubits to qumodes) offer a promising solution by combining the high-dimensional encoding of qumodes with the control and universality of qubits. However, there is a critical lack of standardized benchmarking suites to evaluate these emerging hybrid platforms. Existing tools like SuperMarQ or QASMBench are tailored for DV systems, and no comprehensive framework exists to assess the unique resource requirements, scalability, and performance of hybrid CV-DV circuits.

2. Methodology

The authors introduce HyQBench, a comprehensive simulation and benchmarking framework implemented using Bosonic Qiskit (for gate-level circuit modeling) and QuTiP (for matrix-based functional correctness verification).

A. Benchmark Suite Construction

HyQBench consists of eight representative benchmarks categorized into three hierarchical levels:

1. Primitive Level:
   • State Transfer: Bidirectional transfer of quantum information between a qumode and $N$ qubits using conditional displacement gates.
   • Cat State Protocol: Deterministic generation of even cat states (superpositions of coherent states) without post-selection.
   • GKP State Protocol: Generation of Gottesman-Kitaev-Preskill states (approximate logical qubits) by iteratively applying the Cat State protocol.
2. Algorithmic Level:
   • CV-DV QFT: Performing Quantum Fourier Transform on DV states by mapping them to a qumode, applying a rotation, and mapping back.
   • CV-DV VQE: Solving a Binary Knapsack Problem using a variational ansatz that encodes binary variables into qubit-qumode pairs.
   • CV-QAOA: Solving continuous minimization problems using alternating cost and mixer unitaries on qumodes.
3. Application Level:
   • JCH Simulation: Simulating the Jaynes-Cummings-Hubbard model (coupled cavities with two-level systems) using Trotterization.
   • Shor's Algorithm: Factoring integers using a CV-DV implementation that leverages implicit Fourier transforms via momentum basis measurement, requiring only 3 qumodes and 1 qubit regardless of the integer size.

B. Characterization Metrics

To assess circuit complexity and scalability, the authors define a feature map divided into two categories:

1. General Features: Qubit/qumode counts, gate counts, and circuit depth.
2. CV-DV Specific Features:
   • Wigner Negativity: Quantifies non-classicality; higher values indicate greater difficulty for classical simulation.
   • Truncation Cost: Measures the probability mass in the highest Fock levels; high values indicate a need for larger Hilbert space cutoffs to avoid simulation error.
   • Energy: The average energy of the system (photon number + spin energy) during execution.

3. Key Contributions

• First Comprehensive Hybrid Benchmark Suite: HyQBench fills the void of standardized tools for CV-DV systems, covering primitives, algorithms, and complex applications.
• Novel Metrics: Introduction of Wigner negativity and truncation cost as specific indicators for hybrid circuit complexity and classical simulability.
• Resource Efficiency Analysis: The paper provides analytical comparisons showing that hybrid architectures significantly reduce resource requirements (qubits and gate counts) compared to DV-only or CV-only approaches for specific tasks (e.g., Shor's algorithm, JCH simulation).
• Noise Analysis & Hardware Validation:
  • Simulated noise models (photon loss, qubit dephasing) to predict fidelity degradation.
  • Real Hardware Execution: Successfully ran the Cat State benchmark on the QSCOUT (Sandia National Labs) trapped-ion platform, achieving a fidelity of 0.71. This serves as the first experimental validation of a HyQBench benchmark.

4. Key Results

• Resource Advantages:
  • Shor's Algorithm: The hybrid approach reduces gate complexity from $O(n^3 \log n)$ in DV-only to $O(n^2)$ using only 3 qumodes and 1 qubit.
  • JCH Simulation: Hybrid implementation avoids the exponential qubit overhead required to truncate Fock spaces in DV-only simulations.
  • VQE/QAOA: Hybrid systems require significantly fewer qubits (e.g., 1 qubit + 2 qumodes for VQE) compared to DV-only equivalents.
• Simulation Complexity:
  • Benchmarks like JCH and Cat State exhibit low Wigner negativity and truncation costs, making them easier to simulate classically.
  • CV-QAOA and Shor's Algorithm show high Wigner negativity, indicating strong non-classicality and high classical simulation hardness.
• Noise Sensitivity:
  • Short-duration circuits (Cat, GKP, QFT) maintained high fidelity (>0.97) under simulated photon loss.
  • Long-duration circuits (JCH with 50 Trotter steps, Shor's) suffered significant fidelity drops (down to 0.03 and 0.1, respectively) due to accumulated photon loss, highlighting the need for error correction or faster gates.
• Hardware Validation: The QSCOUT experiment demonstrated that hybrid CV-DV gates are functional on real hardware, though calibration of displacement amplitudes remains a primary source of infidelity.

5. Significance

• Democratization of Hybrid Architectures: By providing an open-source suite, HyQBench lowers the barrier to entry for researchers and hardware developers to test and optimize hybrid quantum systems.
• Hardware Calibration: The suite serves as a practical calibration tool for emerging hardware (like QSCOUT and IQM's hybrid processors), helping to tune gate parameters and assess device performance.
• Future Roadmap: The work establishes a foundation for systematic evaluation of hybrid quantum algorithms, guiding the development of compilers, error correction codes, and hardware architectures specifically designed for the unique properties of CV-DV systems.
• Scalability Insight: The metrics (Wigner negativity, truncation cost) provide a quantitative way to predict when a hybrid system becomes intractable for classical simulation, helping to identify the "quantum advantage" threshold for these architectures.

In conclusion, HyQBench demonstrates that hybrid CV-DV systems are not only viable but offer substantial resource advantages for a wide range of computational tasks, from optimization to integer factorization, while providing the necessary tools to rigorously evaluate their performance and scalability.