⚛️ quantum physics

Benchmarking Digital-Analog Quantum Computation

This paper presents a systematic analysis of Digital-Analog Quantum Computation (DAQC) across arbitrary connectivities and three algorithmic examples, concluding that DAQC is generally disadvantageous compared to standard digital quantum computation except in specific cases.

Original authors: Vicente Pina Canelles, Manuel G. Algaba, Hermanni Heimonen, Miha Papič, Mario Ponce, Jami Rönkkö, Manish J. Thapa, Inés de Vega, Adrian Auer

Published 2026-04-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Vicente Pina Canelles, Manuel G. Algaba, Hermanni Heimonen, Miha Papič, Mario Ponce, Jami Rönkkö, Manish J. Thapa, Inés de Vega, Adrian Auer

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 cook a complex, multi-course meal. You have two ways to do it:

The Digital Chef (Standard Quantum Computing): You follow a strict recipe step-by-step. You chop an onion, then sauté it, then add a spice, then stir. You do one thing at a time, very precisely. If you make a mistake, you can easily see exactly which step went wrong.
The Analog Chef (Digital-Analog Quantum Computing - DAQC): You turn on the stove and let the whole pot simmer naturally. You only intervene occasionally to stir or add a pinch of salt. You rely on the natural flow of the cooking process to do the heavy lifting.

This paper is essentially a benchmarking report comparing these two chefs. The authors wanted to see if the "Analog Chef" (DAQC) is actually faster and better than the "Digital Chef" (DQC), as some had hoped.

The Big Idea: Why try the Analog Chef?

The promise of the Analog Chef is that it's simpler and more robust.

Digital: Requires fine-tuning every single ingredient interaction. It's like trying to juggle while walking a tightrope.
Analog: Uses the natural "vibe" of the kitchen (the device's natural physics). It's like letting a stew simmer; it's harder to mess up the whole pot at once, and you don't need to micromanage every bubble.

The Problem: The Kitchen Layout Matters

The researchers realized that the success of the Analog Chef depends entirely on the layout of the kitchen (the connectivity of the quantum computer).

The "All-to-All" Kitchen: Imagine a kitchen where every station is connected to every other station by a conveyor belt. You can pass ingredients instantly anywhere.
- The Result: The Analog Chef struggled here. To make a specific dish (like a Quantum Fourier Transform), the Analog Chef had to stir the pot so many times to cancel out unwanted flavors that they ended up making more mistakes than the Digital Chef. The "simmering" introduced too much noise.
The "Star" Kitchen: Imagine a kitchen with one central island and spokes leading to outer stations. Everything flows through the center.
- The Result: Here, the Analog Chef shined! Because the natural flow of the kitchen matched the recipe perfectly, the Analog Chef could cook the dish in one giant simmer instead of thousands of tiny steps.

The Three Key Findings

1. The "Over-Engineering" Trap
In most cases, the Analog Chef tries to do too much. To create a specific interaction between two ingredients (qubits), the Analog Chef often has to turn the whole stove on and off repeatedly, flipping signs and canceling things out.

Analogy: It's like trying to paint a single red dot on a wall by spraying the whole wall red, then spraying it white, then red again, just to get that one dot right. The Digital Chef just paints the dot directly. The Analog method creates way more "splatter" (errors) along the way.

2. The Speed vs. Accuracy Trade-off
The Analog Chef is often faster because they can do many things at once (parallel processing).

Analogy: The Digital Chef walks down a hallway opening doors one by one. The Analog Chef opens all the doors at once by pushing a giant lever.
The Catch: While the Analog Chef is faster, the "splatter" (errors) from doing everything at once often ruins the meal before it's done. However, if the kitchen is very old and the doors are sticky (meaning the digital steps take a long time), the Analog Chef's speed might win out.

3. The "Perfect Match" Exception
The Analog Chef only wins when the recipe matches the kitchen's natural layout perfectly.

Analogy: If you are making a soup that naturally flows through the center of the kitchen (like the GHZ state preparation), the Analog Chef is a genius. They can make the whole pot in one go. But if you are trying to bake a cake that requires moving ingredients from the far left to the far right, the Analog Chef gets confused and makes a mess.

The Verdict

The paper concludes that Digital Quantum Computing is generally the safer, more reliable bet for now.

Digital is like a precise robot arm: slow but accurate.
Analog is like a wild, natural force: fast and potentially powerful, but very hard to control.

When should we use the Analog approach?
Only when we are building a very specific machine for a very specific task (like simulating nature or creating specific entangled states) where the "natural flow" of the machine matches the job perfectly. In those rare cases, the Analog Chef can cook a meal in seconds that would take the Digital Chef hours.

Summary in a Nutshell

The authors took a new, exciting idea (Digital-Analog Quantum Computing) and put it through the wringer. They found that while it sounds great in theory, it usually makes more mistakes than the standard method because it tries to force a square peg into a round hole. However, if you build a custom kitchen specifically designed for the recipe, the Analog method can be a game-changer, offering incredible speed and efficiency.

The takeaway: Don't abandon the old, reliable Digital methods yet, but keep an eye on the Analog approach for very specific, specialized jobs.

1. Problem Statement

Digital Quantum Computation (DQC) relies on decomposing algorithms into sequences of single-qubit gates (SQGs) and two-qubit gates (TQGs). While universal, this approach is susceptible to control errors and requires fine-grained calibration for every gate. Digital-Analog Quantum Computation (DAQC) has been proposed as an alternative paradigm. DAQC utilizes the device's natural, continuous evolution under an entangling "resource Hamiltonian" (analog blocks), interleaved with SQGs, to engineer specific "target Hamiltonians."

While DAQC promises robustness against control errors and simpler experimental implementation, previous literature lacked a systematic analysis of its scaling properties across arbitrary device connectivities. It was unclear whether DAQC offers a genuine advantage over DQC in terms of error scaling, execution time, and fidelity, particularly as the number of qubits increases.

2. Methodology

The authors developed a comprehensive framework to analyze DAQC by extending its implementation to arbitrary qubit connectivities (not just all-to-all or linear chains).

General Protocol Formulation:
- They defined a Resource Hamiltonian ( $\bar{H}_C$ ) representing the device's native interactions (assumed to be ZZ-Ising type) and a Target Hamiltonian ( $H_C$ ) representing the desired computation.
- They derived a method to engineer arbitrary target coefficients by running a sequence of $c$ analog blocks (where $c$ is the number of connections).
- By interleaving X gates between analog blocks, they can flip the signs of coupling terms. This creates a linear system of equations ( $G t_f = M t$ ) where the vector of analog block runtimes ( $t$ ) is solved by inverting a sign matrix ( $M$ ) derived from the connectivity.
- They analyzed two paradigms:
  - Stepwise DAQC (sDAQC): Analog blocks are turned on and off sequentially.
  - Banged DAQC (bDAQC): The analog Hamiltonian is always on, with fast SQGs applied as pulses. This introduces non-commutativity (Trotter) errors but avoids ramp-up/down calibration errors.
Error Modeling:
- The authors identified and modeled four primary error sources:
  1. Ramp-up/down errors: Uncertainty in timing when switching analog blocks on/off (relevant for sDAQC).
  2. Coupling mischaracterization: Errors in the coefficients of the resource Hamiltonian.
  3. Non-commutativity errors: Errors arising in bDAQC when SQGs and the analog Hamiltonian do not commute.
  4. Environmental decoherence: Thermal relaxation ( $T_1$ ) affecting the total execution time.
- They derived analytical scaling laws for the number of analog blocks ( $n_{AB}$ ), two-qubit terms ( $n_{TQT}$ ), single-qubit gates ( $n_{SQG}$ ), and execution time ( $t$ ) as a function of qubit count ( $N$ ).
Optimization for Star Connectivity:
- They proposed an optimized protocol for star-connectivity devices (one central qubit connected to $N-1$ outer qubits). By carefully arranging X gates, they constructed a specific sign matrix $M$ that minimizes the number of analog blocks and runtimes, effectively reducing the algorithm to a single analog block for certain homogeneous Hamiltonians.
Numerical Simulation:
- They simulated three algorithms: Quantum Fourier Transform (QFT) and GHZ state preparation on both All-to-All (ATA) and Star connectivities.
- Simulations used a realistic error model for superconducting qubits (systematic and stochastic control errors, thermal relaxation) to calculate average fidelities and execution times.

3. Key Contributions

Generalization of DAQC: Provided the first general protocol for implementing universal DAQC on devices with arbitrary connectivity, moving beyond the restricted all-to-all or linear chain models.
Systematic Error Scaling Analysis: Derived explicit scaling laws showing that DAQC generally introduces a super-linear number of two-qubit terms ( $O(N^5)$ for ATA-QFT) compared to DQC ( $O(N^2)$ ), leading to worse error scaling in most cases.
Star-Connectivity Optimization: Demonstrated that for specific connectivities (Star) and specific algorithms (GHZ), DAQC can outperform DQC. In the GHZ case, the target Hamiltonian matches the resource Hamiltonian, allowing the entire operation to be performed in a single analog block, reducing execution time from $O(N)$ to $O(1)$ .
Trade-off Analysis: Identified a regime where DAQC might outperform DQC: when the execution time of digital TQGs is very slow or qubit coherence times ( $T_1$ ) are very short. In these cases, the reduced execution time of DAQC (despite higher control error accumulation) can lead to higher total fidelity due to reduced decoherence.

4. Results

General Disadvantage: For standard algorithms like QFT on All-to-All (ATA) connectivity, DAQC performs worse than DQC.
- Fidelity: DAQC fidelities drop significantly faster as $N$ increases. For $N=3$ , ATA-QFT in DQC uses 3 TQGs, while DAQC requires 18 two-qubit terms (due to the $c^2$ scaling of analog blocks).
- Time: The execution time for DAQC scales as $O(N^{2.05})$ for ATA-QFT, whereas DQC scales linearly $O(N)$ .
Star-Connectivity Nuances:
- QFT: DAQC on a star topology improves over the ATA case but still generally underperforms DQC in fidelity, though it offers a linear time scaling ( $O(N)$ ) compared to DQC's quadratic scaling ( $O(N^2)$ ).
- GHZ State: DAQC outperforms DQC. Because the GHZ state preparation on a star graph is naturally a single analog block, DAQC achieves constant execution time ( $O(1)$ ) and higher fidelity by parallelizing interactions that DQC must perform sequentially.
bDAQC vs. sDAQC:
- In the Star-QFT case, bDAQC outperforms sDAQC for $N > 6$ . This is because the non-commutativity error in bDAQC scales favorably ( $O(1)$ per block for star topology) compared to the ramp-up/down errors in sDAQC.
Fidelity vs. Time Trade-off:
- Numerical simulations show that while DAQC accumulates more control errors, its shorter execution time can mitigate decoherence. If TQGs are slow (e.g., 300ns) or $T_1$ is short (e.g., 50 $\mu$ s), DAQC can achieve higher total fidelity than DQC for sufficiently large $N$ .

5. Significance

This paper provides a critical "reality check" for the DAQC paradigm. It clarifies that DAQC is not a universal panacea for near-term quantum computing.

When to use DAQC: It is most advantageous when the target Hamiltonian closely matches the device's native resource Hamiltonian (e.g., GHZ state preparation on a star graph) or when the algorithm requires parallelizing many interactions that would be sequential in DQC.
When to avoid DAQC: For sparse algorithms (like QFT) on generic connectivities, the overhead of canceling unwanted couplings via multiple analog blocks introduces too many error-prone terms, making DQC superior.
Future Direction: The work suggests DAQC is a promising tool for quantum simulation and variational algorithms where the goal is to generate entanglement across the whole device quickly, rather than for general-purpose universal gate-based computation.

In conclusion, the authors establish that while DAQC offers potential speedups and robustness in specific, tailored scenarios, it generally suffers from unfavorable error scaling compared to standard digital quantum computation.