Arbitrary parallel entangling gates with independent calibration on a trapped ion quantum computer

This paper demonstrates a new method for executing arbitrary parallel entangling gates on a trapped-ion quantum computer with independent calibration, achieving near-linear speedup and high fidelity across various graph patterns, thereby motivating future architectures based on multiple medium-length ion chains.

The Gist

Imagine a quantum computer as a busy kitchen where chefs (qubits) need to work together to prepare a complex meal (a calculation). Usually, if two chefs need to swap ingredients to finish a dish, they have to do it one pair at a time. If you have ten chefs, that means nine separate trips to the pantry, one after another. This takes a long time, and the longer the meal takes, the more likely the food is to spoil (errors creep in).

This paper introduces a new way to run a "trapped-ion" quantum computer (a type of computer that uses floating atoms as its chefs). The researchers have developed a method to let multiple pairs of chefs swap ingredients simultaneously, without them bumping into each other or messing up the other dishes.

Here is the breakdown of their discovery using simple analogies:

1. The Problem: The "One-at-a-Time" Traffic Jam

In the past, if you wanted to entangle (connect) multiple pairs of atoms at the same time, the computer had to be very picky.

• The Old Way: It was like trying to coordinate a dance where everyone has to move in perfect lockstep, but you could only teach one pair of dancers at a time. If you wanted to change the dance pattern (the "graph"), you had to stop, re-teach the whole routine, and start over.
• The Calibration Nightmare: To get the timing right for 100 different pairs, you usually only have 10 "volume knobs" (calibration controls). Trying to tune 100 different songs with only 10 knobs is mathematically impossible without them clashing.

2. The Solution: The "Radio Frequency" Trick

The authors created a new method to generate the "music" (laser pulses) that tells the atoms what to do.

• Different Frequencies: Imagine the chefs are listening to a radio. Instead of everyone listening to the same station, the researchers tuned each pair of chefs to a slightly different radio frequency.
• Silence the Noise: By carefully designing the music, they ensured that Chef A and Chef B only hear their own song, while Chef C and Chef D hear a different one. Even though they are all in the same room (the same ion chain), they don't accidentally dance to each other's music.
• The "Universal Playlist": The best part is that they created one master playlist that works for any combination of pairs. Whether you want to connect Chef 1 to Chef 2, or Chef 5 to Chef 9, or all of them at once, you just use the same playlist. You don't need to write new music for every new recipe.

3. The Results: Speed and Accuracy

The team tested this on a real quantum computer with a chain of 7 atoms (using 5 as the "chefs").

• Speed: When they ran three different famous quantum algorithms (like a "Hidden Shift" puzzle and a "Bernstein-Vazirani" code breaker), the parallel method was roughly twice as fast as doing the steps one by one. In some cases, it was even faster.
• Quality: Usually, doing things faster makes them messier. But here, the "parallel" dishes were just as high-quality as the "serial" (one-by-one) dishes. The error rates remained low.
• Flexibility: They tested different shapes of connections:
  • Disjoint: Two separate pairs working alone (like two couples dancing in a corner).
  • Star Graph: One central chef connecting to everyone else (like a hub).
  • Ring Graph: Everyone connecting to their neighbor in a circle.
  • In all cases, the method worked without needing to re-calibrate the machine for every new shape.

4. Why This Matters for the Future

The paper suggests that future quantum computers shouldn't just try to make one giant chain of atoms (which gets hard to control) or many tiny, separate chains (which are slow to move atoms between).

Instead, they propose building medium-sized chains (like 10–20 atoms) that can do many things at once. Because this new method allows for "arbitrary" connections (any pattern you want) without the usual calibration headaches, it makes these medium-sized chains much more powerful and efficient.

In short: They figured out how to let a group of atoms talk to each other in pairs, all at the same time, using a single set of instructions that works for any pattern, making the quantum computer faster and easier to tune.

Technical Summary

1. Problem Statement

Parallel processing is essential for achieving practical quantum advantage, as it significantly reduces circuit depth and execution time compared to serial gate execution. While trapped-ion quantum computers offer complete qubit connectivity, enabling arbitrary patterns of two-qubit entangling gates, existing methods for parallelizing these gates face critical limitations:

• Calibration Complexity: Prior methods often require tailor-made pulse synthesis for every specific gate pattern. Calibrating $O(N^2)$ entangling angles using only $O(N)$ independent control parameters (pulse amplitudes per ion) is mathematically constrained, making independent calibration of arbitrary patterns difficult or impossible.
• Crosstalk and Power: Simultaneously driving multiple gates often leads to significant crosstalk between qubit pairs and requires excessive laser power, which can exceed hardware limits or degrade fidelity.
• Scalability: Previous approaches (e.g., Refs. [1, 2]) suffer from high pulse complexity, lack of stability against frequency drifts, or inability to handle overlapping qubit patterns (e.g., star graphs) efficiently without re-synthesis.

2. Methodology

The authors propose a novel method for synthesizing gate pulses that allows for arbitrary parallel entangling gates with independent calibration. The core innovation lies in separating gate pulses into different frequency bands to minimize crosstalk and using an iterative projection method to suppress residual interference.

The process involves three main steps:

1. Basis Definition and Null-Space Constraint (Step 1):

   • The pulse functions $g_i(t)$ are constructed using a Fourier basis (sine functions).
   • To ensure the qubits are decoupled from motional modes at the end of the gate (satisfying $\alpha_{ip} = 0$), the pulses are constrained to the null space of a matrix $\hat{M}$ derived from the Lamb-Dicke parameters and mode frequencies. This guarantees that the transient spin-motion entanglement is removed.

2. Mode Assignment and Ordering (Step 2):

   • The authors formulate a maximum weight matching problem to assign specific qubit pairs $(i, j)$ to specific motional modes $p$ and eigenvalues $\lambda$.
   • The goal is to maximize power efficiency by pairing qubits with modes that have the strongest coupling ($\eta_{ip}\eta_{jp}\Lambda_{p,\lambda}$).
   • Gates are ordered for synthesis based on these assignments, prioritizing those with lower power requirements (higher coupling efficiency) to be solved first.

3. Iterative Pulse Synthesis with Crosstalk Suppression (Step 3):

   • Pulses are solved iteratively. For the $m$-th gate, the solution space is constrained to be orthogonal to all previously solved pulses ($m' < m$).
   • A projector operator $\hat{Q}$ is constructed to explicitly cancel unwanted crosstalk terms ($\chi_{ij}$) between the current gate and all previously solved gates.
   • This ensures that while the pulses share the same frequency band, they do not interfere with each other's entanglement angles.

Key Features of the Method:

• Single Pulse Set: A single set of $O(N^2)$ pulse solutions is generated for all possible two-qubit gates. Any subset (graph pattern) can be implemented by simply selecting the relevant pulses, avoiding the need for re-synthesis.
• Independent Calibration: Because crosstalk is mathematically nulled, each gate in a parallel set can be calibrated independently by adjusting its specific amplitude, similar to serial gates.
• Power Rebalancing: For overlapping gates (e.g., a star graph where one qubit participates in multiple gates), the method employs power rebalancing. The central qubit's power is reduced by $\sqrt{d}$ (where $d$ is the degree), and peripheral qubits are increased, maintaining the total entanglement angle while keeping peak power feasible.

3. Key Contributions

• Graph-Pattern Agnostic Implementation: The method supports any arbitrary graph pattern (disjoint pairs, star graphs, ring graphs) without requiring new pulse synthesis for each configuration.
• Independent Calibration: It solves the calibration bottleneck by allowing $O(N)$ gates to be calibrated simultaneously with $O(N)$ control knobs, a feat previously limited to disjoint pairs in other methods.
• Stability: The pulses are designed to be stable against drifts in motional mode frequencies (a feature often missing in prior parallel schemes).
• Memory Efficiency: By storing a single universal pulse set rather than $2^{O(N^2)}$ specific patterns, the method drastically reduces the memory requirements for quantum control electronics (FPGAs).

4. Experimental Results

The authors implemented these gates on a 171Yb+ trapped-ion quantum computer using a 7-ion chain (5 active qubits).

• Gate Fidelity:
  • Disjoint Gates: Parallel execution of two disjoint XX gates achieved fidelities of 98.48% and 98.58%, comparable to serial gates (~98.5%).
  • Overlapping Gates: A parallel implementation of two gates sharing one ion achieved 94.99% fidelity, comparable to the serial equivalent (96.15%).
• Algorithm Benchmarks:
  • Hidden Shift (HS) Algorithm: Parallel implementation reduced execution time by ~50% and improved average fidelity to 94.58% (vs. 93.15% serial).
  • Bernstein-Vazirani (BV) Algorithm: Parallelization reduced execution time significantly (from $4\tau$ to $\tau$ or $2\tau$ depending on the oracle). Fidelity remained high at 97.01%.
  • Heisenberg Hamiltonian (HH) Simulation: A 4-qubit simulation of a ring graph (all-to-all connectivity) showed a 4x speedup in execution time. The parallel implementation yielded a mean squared distance to the ideal simulation of 0.016, significantly better than the serial implementation's 0.037.
• Power Scaling:
  • For $O(N)$ parallel gates, the average power requirement scales linearly with $N$, comparable to a single gate.
  • The method avoids the exponential power explosion seen in other schemes when scaling to all-to-all connectivity.

5. Significance and Future Outlook

• Architectural Impact: The results suggest that future trapped-ion quantum computers should utilize multiple medium-length ion chains rather than a single massive chain or many tiny disjoint chains. This architecture maximizes the benefits of parallelization while mitigating mode crowding and shuttling overhead.
• Fault Tolerance: The ability to execute stabilizer readouts and transversal logical gates in parallel is crucial for error correction schemes (e.g., surface codes), where parallelization can drastically reduce the time overhead of syndrome extraction.
• Scalability: By decoupling pulse synthesis from specific graph patterns and enabling independent calibration, this method removes a major bottleneck in scaling trapped-ion systems to hundreds of qubits.

In summary, this work demonstrates a robust, scalable, and experimentally verified framework for parallel entangling gates that overcomes the calibration and crosstalk limitations of previous approaches, paving the way for more efficient and faster quantum algorithms on trapped-ion hardware.