⚛️ quantum physics

Digital Quantum Simulation of the Holstein-Primakoff Transformation on Noisy Qubits

This paper demonstrates the digital quantum simulation of bosonic systems using the Holstein-Primakoff transformation on a noisy superconducting quantum processor, successfully realizing driven harmonic oscillator and Jaynes-Cummings models while systematically analyzing the interplay between algorithmic and hardware-induced errors to establish a framework for future complex spin-boson simulations.

Original authors: Kelvin Yip, Alessandro Monteros, Sahel Ashhab, Lin Tian

Published 2026-02-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Kelvin Yip, Alessandro Monteros, Sahel Ashhab, Lin Tian

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 simulate a complex dance party inside a computer. But there's a catch: the "dancers" in this party are bosons (particles like light or sound waves). In the real world, these dancers can do an infinite number of moves. They can spin, jump, or stand still in an endless variety of ways.

The problem? The quantum computers we have today are like a small room with only a few chairs. They can't hold an infinite number of dancers. If you try to put an infinite crowd into a small room, the simulation crashes or becomes incredibly messy.

This paper is about a clever trick the researchers used to fit this "infinite dance party" into a "small room" of quantum computers, and how they figured out how to do it without the dancers tripping over each other.

The Big Idea: The "Crowd Surfer" Trick

To solve the problem of infinite space, the researchers used a mathematical tool called the Holstein-Primakoff (HP) transformation.

Think of it this way:

The Problem: You want to simulate a single, super-flexible dancer (a boson) who can do infinite moves.
The Solution: Instead of one flexible dancer, you hire a team of rigid dancers (qubits, the basic units of a quantum computer).
The Analogy: Imagine a single flexible gymnast. Now, imagine replacing her with a line of 10 stiff soldiers. If one soldier flips up, it looks like a small move. If five soldiers flip up, it looks like a bigger move. If all 10 flip, it looks like a huge move.

By using a team of soldiers (qubits) to mimic the moves of the gymnast (boson), the researchers can simulate the "infinite" dancer using a finite number of chairs. The more soldiers you have, the more accurately you can mimic the gymnast's flexibility.

The Two Dance Routines They Tested

The team tested this trick on two famous "dance routines" (physics models) to see if it worked:

The Driven Harmonic Oscillator: Imagine a swing being pushed back and forth by a parent. The researchers simulated a swing that gets pushed by a rhythmic force. They wanted to see if their "soldier team" could mimic the swing's motion perfectly.
The Jaynes-Cummings Model: This is like a game of catch between a ball (the boson) and a player (a qubit). The ball is thrown to the player, who catches it and throws it back. They wanted to see if the "soldier team" could simulate this back-and-forth exchange of energy accurately.

The "Noise" Problem: When the Room Gets Noisy

Here is the tricky part. Real quantum computers (like the ones the researchers used, which are made of superconducting circuits) are noisy. They are like a dance floor that is slippery, dimly lit, and has people shouting.

Algorithmic Errors (The "Math" Mistake): If you use too few soldiers (qubits) to mimic the gymnast, the simulation is mathematically wrong because you can't represent big moves. It's like trying to describe a giant leap using only 2 soldiers; you just can't do it.
Hardware Errors (The "Real World" Mistake): If you use too many soldiers, the line gets too long. In a noisy room, the longer the line, the more likely someone is to slip, trip, or get confused by the noise. The quantum computer's gates (the instructions) aren't perfect, and reading the results (measuring the dancers) is also prone to errors.

The Goldilocks Discovery

The researchers ran thousands of simulations to find the "Goldilocks" zone—the perfect balance.

Too few qubits? The math is too rough (Algorithmic error is high).
Too many qubits? The noise takes over, and the simulation gets messy (Hardware error is high).
Just right? They found that for their specific setup, using about 12 qubits was the sweet spot. It was enough to mimic the physics accurately, but not so many that the computer's noise ruined the result.

They also tried a second method called "Synthesized Unitary" (think of it as choreographing a specific, optimized dance routine rather than following a step-by-step instruction manual). They found that for small systems, this custom choreography was much better and faster than the standard step-by-step method.

Why Does This Matter?

This paper is a roadmap for the future.

It proves we can simulate "light" and "sound" on computers built for "matter." Bosons (like light) and fermions (like electrons) are usually treated differently. This work shows we can use standard quantum computers to study light-matter interactions, which is crucial for things like better solar panels, lasers, and quantum sensors.
It teaches us how to work with "imperfect" computers. We don't have perfect quantum computers yet. This study gives us a framework for how to get the best possible results out of the noisy, imperfect machines we have today.
It opens the door to bigger simulations. Once we master simulating one "boson" with a team of qubits, we can eventually simulate complex systems with many bosons, helping us understand new materials and the fundamental laws of the universe.

In short: The researchers figured out how to translate an infinite, complex dance into a finite, manageable routine using a team of digital dancers. They learned exactly how many dancers they need to get the best performance without tripping over the noise in the room. This is a major step toward using quantum computers to solve problems that are currently impossible for our best supercomputers.

1. Problem Statement

Digital quantum simulation offers a pathway to explore complex many-body quantum dynamics that are intractable for classical computers. While spin and fermionic systems have been extensively simulated, bosonic systems present a fundamental challenge for digital quantum processors.

The Core Issue: Bosonic modes possess an infinitely large Hilbert space, whereas current noisy intermediate-scale quantum (NISQ) processors have a finite number of qubits and limited coherence times.
Current Limitations: Traditional digital approaches often truncate the bosonic Hilbert space to a small number of excitations, mapping Fock states to multi-qubit states. However, simulating bosonic dynamics directly on qubit-based hardware without a robust mapping strategy remains difficult due to the trade-off between algorithmic accuracy (requiring many qubits) and hardware noise (which increases with circuit depth and qubit count).
Goal: The authors aim to investigate the feasibility of simulating bosonic modes using the Holstein-Primakoff (HP) transformation on a cloud-based superconducting quantum processor (IBM Quantum), specifically analyzing the interplay between algorithmic approximations and hardware-induced errors.

2. Methodology

The study employs the Holstein-Primakoff (HP) transformation, which maps a single bosonic mode onto an ensemble of $N$ spins (qubits).

The HP Mapping:
- Bosonic creation/annihilation operators ( $a^\dagger, a$ ) are mapped to collective angular momentum operators ( $J_+, J_-, J_z$ ) of a spin ensemble.
- In the limit of large $N$ (where $N \gg \langle a^\dagger a \rangle$ ), the square-root factors in the exact HP transformation are approximated, allowing the bosonic operators to be represented by normalized collective spin-raising and lowering operators.
- The bosonic ground state $|0\rangle$ corresponds to the fully polarized spin-down state, while excited states correspond to Dicke states (symmetric superpositions of spin flips).
Models Simulated:
1. Driven Harmonic Oscillator: A bosonic mode driven by an external field. The Hamiltonian is mapped to a sum of single-qubit terms, requiring only single-qubit gates.
2. Jaynes-Cummings (JC) Model: Describes the interaction between a bosonic cavity mode and a two-level system (qubit). This requires two-qubit interactions (XX and YY couplings) between the cavity qubits and the system qubit.
Implementation Strategies:
- Platform: Experiments were conducted on the IBM Torino superconducting quantum processor using the Qiskit framework.
- Approach 1 (Trotterization): For the JC model, the authors used Suzuki-Trotter decomposition (second-order) to approximate time evolution. They varied the number of Trotter steps ( $K_T$ ) to study the trade-off between algorithmic error (decreasing with more steps) and hardware error (increasing with circuit depth).
- Approach 2 (Synthesized Unitary): To mitigate two-qubit gate errors, they employed a synthesized unitary approach. This involves a fixed circuit layout with a small number of two-qubit gates (CZ) interleaved with tunable single-qubit rotations. The rotation parameters were optimized classically to maximize fidelity against the target unitary.
Error Analysis Framework:
The authors systematically quantified three types of errors:
1. Algorithmic Error ( $\Delta P_a$ ): Arising from the finite number of qubits ( $N$ ) in the HP mapping and the finite number of Trotter steps.
2. Hardware Error ( $\Delta P_e$ ): Arising from gate infidelity (especially two-qubit CZ gates), decoherence, and readout errors.
3. Total Deviation ( $\Delta P_{tot}$ ): The combined error compared to the exact analytical solution.

3. Key Contributions

First Cloud-Based HP Simulation: Demonstrated the digital simulation of bosonic modes using the HP transformation on a real, noisy superconducting quantum processor.
Quantification of Error Trade-offs: Provided a systematic analysis showing that increasing the system size (number of qubits) or Trotter steps does not monotonically improve accuracy. Instead, there is an optimal operating point where algorithmic errors and hardware errors balance to minimize total deviation.
Synthesized Unitary Optimization: Showed that for small systems, a synthesized unitary approach with optimized parameters can significantly outperform standard Trotterization by reducing the number of noisy two-qubit gates.
Hardware Benchmarking: Isolated the dominant noise sources, identifying two-qubit gate errors (CZ) and readout errors as the primary bottlenecks, rather than single-qubit gate errors.

4. Key Results

Driven Harmonic Oscillator:
- Simulations were run with varying qubit numbers ( $N$ ).
- Result: As $N$ increased, algorithmic error decreased, but hardware error (accumulated readout and gate noise) increased.
- Optimal Point: For a driving strength $F=0.75$ , the total error reached a minimum at $N \approx 12$ . For weaker driving ( $F=0.3$ ), algorithmic error was negligible, and total error was dominated by hardware noise.
- Dominant Hardware Error: Readout error was found to be the primary source of hardware inaccuracy for this single-qubit gate circuit.
Jaynes-Cummings Model:
- Trotterization: Increasing Trotter steps ( $K_T$ ) reduced algorithmic error but increased hardware error due to the accumulation of CZ gates. The optimal number of steps was found to be $K_T \approx 4$ .
- Synthesized Unitary vs. Trotter:
  - The six-CZ-gate synthesized layout achieved a significantly lower total probability difference ( $\Delta P_{tot} \approx 0.06$ ) compared to the optimal Trotter case ( $K_T=4$ , $\Delta P_{tot} \approx 0.10$ ) and the single-step Trotter case ( $\Delta P_{tot} \approx 0.29$ ).
  - This confirms that reducing the number of two-qubit gates via circuit synthesis is highly effective on current noisy hardware.
- Noise Benchmarking: A benchmark circuit containing only CZ gates (removing single-qubit rotations) confirmed that two-qubit gate errors are the dominant source of noise, with error rates around $3 \times 10^{-2}$ .

5. Significance and Conclusion

Framework for Bosonic Simulation: The work establishes a practical framework for simulating bosonic degrees of freedom on digital quantum processors using the HP transformation, extending beyond simple spin models.
Algorithm-Hardware Co-Design: The study highlights the critical importance of co-designing algorithms with hardware constraints. Simply increasing system size or simulation steps is insufficient; one must identify the "sweet spot" where algorithmic approximations and hardware noise are balanced.
Scalability: While the synthesized unitary approach is limited by classical optimization costs for large systems, the demonstrated success with the HP mapping and error mitigation strategies paves the way for simulating more complex spin-boson and multimode cavity models in the NISQ era.
Future Outlook: The methods presented can be extended to study novel physical phenomena in quantum optics, condensed matter physics, and quantum chemistry involving bosonic fields.

In summary, this paper successfully bridges the gap between theoretical bosonic models and experimental quantum hardware, providing a roadmap for optimizing digital quantum simulations in the presence of noise.