⚛️ quantum physics

Digital-Analog Quantum Computing with Qudits

This paper extends the digital-analog quantum computing paradigm from qubits to qudits by utilizing Weyl-Heisenberg gates to simulate arbitrary two-body Hamiltonians with $O(d^4 n^2)$ analog blocks, demonstrating its effectiveness through the simulation of many-body qudit spin systems.

Original authors: Alatz Alvarez-Ahedo, Mikel Garcia de Andoin, Mikel Sanz

Published 2026-03-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Alatz Alvarez-Ahedo, Mikel Garcia de Andoin, Mikel Sanz

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

The Big Picture: Building a Better Quantum Kitchen

Imagine you are trying to cook a very specific, complex dish (a quantum simulation). You have two ways to do it:

The Analog Chef (AQC): You have a giant, magical stove that naturally simulates the heat of a fire. It's great at cooking "fire dishes," but if you want to cook a "frosty dessert," the stove can't do it directly. It's robust and hard to break, but not very versatile.
The Digital Chef (DQC): You have a robot arm that can pick up any ingredient and chop it perfectly. It can make anything, but the robot is very sensitive. If the kitchen is noisy or the robot shakes, the food gets ruined. To fix this, you need a huge team of backup robots (error correction), which takes up a lot of space and resources.

The Problem: We are currently in the "Noisy Intermediate-Scale Quantum" (NISQ) era. Our quantum computers are like those shaky robot arms. They are too noisy to run complex digital recipes perfectly, but they aren't versatile enough to just "be" the analog stove.

The Solution (DAQC): The authors propose a Digital-Analog approach. Imagine a hybrid kitchen where you use the sturdy, natural stove (Analog) to do the heavy lifting, but you use a few precise digital tools (like a digital timer or a specific spice shaker) to tweak the flavor. This gives you the best of both worlds: the robustness of the stove and the flexibility of the robot.

The New Twist: From "Bits" to "Qudits"

Until now, this hybrid kitchen only worked with Qubits.

Qubits are like light switches: they are either OFF (0) or ON (1).
Qudits are like dimmer switches or a piano keyboard. They can be 0, 1, 2, 3... up to d.

The paper says: "Why limit ourselves to just on/off switches when we have dimmer switches?"

Using Qudits (multi-level systems) is like upgrading from a binary code (0s and 1s) to a full alphabet. You can write a whole sentence with fewer letters. In quantum terms, this means you need fewer steps to do the same job, which reduces the chance of errors in our noisy kitchen.

The Core Idea: The "Flavor-Changing" Recipe

The authors figured out how to extend the Digital-Analog method to these fancy Qudits. Here is how it works, step-by-step:

1. The "Source" Hamiltonian (The Stove)

You have a physical system (like a superconducting circuit or trapped ions) that naturally wants to interact in a specific way. Let's call this your Source Hamiltonian. It's like a stove that naturally simulates "spicy heat."

2. The "Target" Hamiltonian (The Recipe)

You want to simulate a different interaction, maybe "sweet coldness." This is your Target Hamiltonian.

3. The Magic Trick: Conjugation

How do you turn "spicy heat" into "sweet coldness" without changing the stove? You use Qudit Gates (the digital tools).

The Analogy: Imagine the stove is a giant drum. If you hit it normally, it makes a low boom (the natural interaction).
If you put a specific muffler (a Qudit gate) on the drum, hit it, and then take the muffler off, the sound changes.
The authors use a special set of tools called the Weyl-Heisenberg basis. Think of these as a specific set of mufflers and amplifiers that can twist the sound of the drum in every possible direction.

By applying these tools in a specific sequence, they can mathematically "rotate" the natural interaction of the stove until it perfectly mimics the complex recipe you wanted.

The Math Part (Simplified)

The paper does a lot of heavy math to prove two things:

It's possible: No matter what recipe you want, you can find a combination of these "mufflers" to make the stove do it.
It's efficient: You don't need an infinite number of steps. The number of steps grows in a manageable way (polynomially) even as you add more Qudits.

They created a giant instruction manual (Matrix M).

The rows are the different parts of the recipe you want to simulate.
The columns are the different ways you can twist the stove with your digital tools.
The goal is to solve the puzzle: "Which tools do I use, and for how long, to get the exact flavor I want?"

The Results: The "Qutrit" Test

To prove it works, they tested it with Qutrits (3-level systems, like a switch that can be Red, Green, or Blue).

They simulated a complex magnetic model (the "Bilinear-Biquadratic Ising model").
They compared their Digital-Analog Qudit method against a purely Digital method.
The Result: In many cases, their hybrid method was more accurate (higher fidelity) than the purely digital one, especially when the noise was high. It was like using the sturdy stove with a few tweaks beat the shaky robot arm trying to do everything from scratch.

Why This Matters

Less Noise, More Power: By using Qudits, we can do more complex calculations with fewer steps, which means fewer chances for errors to creep in.
Real-World Ready: This method is designed for the quantum computers we have right now (the noisy ones), not just the perfect ones of the future.
New Physics: It allows us to simulate things we couldn't easily do before, like complex magnetic materials with "quadrupolar" terms (think of magnets that don't just point North/South, but have more complex shapes).

Summary in One Sentence

The authors have invented a new way to run quantum computers that uses the natural "muscle" of multi-level particles (Qudits) combined with smart digital tweaks, allowing us to simulate complex physics more accurately and efficiently on today's noisy machines.

1. Problem Statement

Current quantum computing research is dominated by the Noisy Intermediate-Scale Quantum (NISQ) era, where hardware is limited by noise and error rates.

Digital Quantum Computing (DQC): Offers universality via discrete gate sequences but suffers from high noise susceptibility and requires extensive error correction overhead.
Analog Quantum Computing (AQC): Uses continuous Hamiltonian evolution, which is more robust to noise but lacks the versatility to simulate arbitrary Hamiltonians or run general algorithms.
Digital-Analog Quantum Computing (DAQC): A hybrid paradigm that combines the robustness of AQC (using the system's natural entangling Hamiltonian) with the flexibility of DQC (using local single-qubit gates to conjugate the Hamiltonian).
The Gap: Existing DAQC protocols are primarily designed for qubits (2-level systems). However, many physical platforms (superconducting circuits, trapped ions) naturally support qudits ( $d$ $d$ -level systems, where $d > 2$ $d > 2$ ). Extending DAQC to qudits is crucial for:
- Reducing the number of entangling operations (increasing efficiency).
- Naturally simulating high-dimensional spin phenomena (e.g., magnetic quadrupolar terms).
- Avoiding the resource overhead of mapping bosonic or high-spin systems onto qubits.

2. Methodology

The authors propose a constructive protocol to extend the DAQC framework from qubits to arbitrary $d$ -level systems (qudits).

A. Theoretical Framework

Goal: Simulate a target propagator $U_P = e^{-iT H_P}$ (where $H_P$ is an arbitrary two-body qudit Hamiltonian) using a source Hamiltonian $H_S$ provided by the hardware.
Mechanism: The target evolution is synthesized by conjugating the source Hamiltonian $H_S$ with local unitary gates $G_q$ drawn from the Weyl-Heisenberg basis.
$U_P \approx \prod_q G_q^\dagger e^{-i t_q H_S} G_q$
The Weyl-Heisenberg Basis: Instead of Pauli matrices ( $\sigma_x, \sigma_y, \sigma_z$ ) used for qubits, the protocol utilizes generalized operators $W_{nm} = Z^n X^m$ . These operators form a complete basis for $SU(d)$ and satisfy specific commutation relations that allow for phase manipulation of couplings.
Linear System Formulation: The problem is reduced to solving a linear system of equations $M \vec{t} = T \vec{h}_{p/h_s}$ $M t = T h_{p / h_{s}}$ , where:
- $\vec{t}$ represents the time durations of the analog blocks.
- $M$ is a matrix encoding the phase shifts introduced by the conjugation operations.
- The rows correspond to the coupling constants of the target Hamiltonian, and columns correspond to the effective signs/phases generated by the local operators.

B. Key Mathematical Proofs

The paper provides rigorous proofs (in Appendices A and B) to ensure the protocol's validity:

Existence of Solution: The authors prove that the sub-matrix $M[2]$ (representing conjugations by two single-qudit gates) has a non-zero determinant. This guarantees that a solution for the time durations $\vec{t}$ exists.
Positive Time Solution: Using Carathéodory's theorem and polytope geometry, they demonstrate that a solution exists where all time durations $t_q$ are positive, ensuring physical implementability.
Complexity: The protocol requires at most $O(d^4 n^2)$ analog blocks for $n$ qudits, which is polynomially fewer than previous methods that attempted to isolate every coupling individually.

C. Special Case: Spin Systems

The authors show that for Hamiltonians expressed in the spin operator basis ( $S_x, S_y, S_z$ ), the protocol simplifies significantly. If the experimental platform can implement rotations $e^{-i\pi S_\nu}$ , the complexity reduces to $O(n^2)$ with only $4n$ columns in the matrix $M$ , mirroring the efficiency of the qubit case.

3. Key Contributions

Generalization to Qudits: The first constructive protocol to extend DAQC to arbitrary $d$ -level systems using the Weyl-Heisenberg operator basis.
Efficient Simulation: A method to simulate arbitrary two-body qudit Hamiltonians with a resource scaling of $O(d^4 n^2)$ , significantly improving upon previous non-constructive or less efficient approaches.
Spin-Basis Adaptation: A specific derivation showing that for $SU(2)$ spin systems (even with $d>2$ ), the protocol retains the low complexity ( $O(n^2)$ ) of the original qubit DAQC.
New Effective Operators: The formalism allows for the generation of new effective operators. For example, distinct elements in a basis sharing identical Weyl components can be transformed into one another (demonstrated by converting between linear and quadratic spin operators).

4. Results and Numerical Validation

The authors validated the protocol using a qutrit ( $d=3$ ) example:

Target Hamiltonian: An isotropic bilinear-biquadratic (BLBQ) Ising-like Hamiltonian for spin $s=1$ .
Source Hamiltonian: An Ising-like $S_z S_z$ interaction.
Simulation Approach: They employed the banged-DAQC (bDAQC) approach, where the Hamiltonian remains active while single-qutrit gates are applied, as this is more experimentally feasible than switching the Hamiltonian on/off.
Performance Metrics:
- Fidelity: The simulation was compared against a fully digital approach (DQC) using a problem-tailored gate set.
- Regimes: The fidelity varied based on the parameter $\theta$ $θ$ in the Hamiltonian.
  - At $\theta = 0$ , fidelity was near-perfect (no gates needed).
  - In the region $\theta < \pi/2$ , bDAQC outperformed DQC.
  - In the region $\pi/2 < \theta < \pi$ , fidelity dropped due to the increased number of required single-qutrit gates (up to 27 gates), introducing gate errors.
  - Near $\theta = \pi$ , fidelity improved again as some short time blocks were discarded, reducing the gate count to 9.
Conclusion on Results: The DAQC approach achieved comparable performance to the digital approach while utilizing the system's natural entangling dynamics, demonstrating its viability in the NISQ era.

5. Significance and Future Outlook

NISQ Advantage: This work provides a comprehensive experimental framework for implementing DAQC on state-of-the-art platforms (e.g., ion traps, superconducting circuits) that natively support qudits. It eliminates the need for complex multi-qubit mappings for bosonic or high-spin simulations.
Resource Efficiency: By leveraging the higher dimensionality of qudits, the protocol reduces the number of entangling operations required, which is a primary source of error in current quantum processors.
Future Directions: The authors identify the mitigation of Trotter errors as a critical future challenge. Unlike qubits, Trotter errors in qudit systems scale with both the number of qudits ( $n$ ) and their dimensionality ( $d$ ). Developing strategies to minimize these errors is essential for scaling these algorithms.

In summary, this paper successfully bridges the gap between digital-analog quantum computing and high-dimensional quantum systems, offering a robust, resource-efficient pathway for simulating complex many-body physics and gauge theories on near-term quantum hardware.