Robust and optimal control of open quantum systems

This paper presents a scalable algorithm for robust and optimal control of open quantum systems that effectively mitigates imperfections and decoherence, achieving an ultra-low infidelity of 0.60% in superconducting circuits with computational complexity comparable to conventional closed-system methods.

The Gist

Imagine you are trying to bake the perfect soufflé. You have a recipe (the quantum algorithm) and a kitchen (the quantum computer). In a perfect world, if you follow the recipe exactly, the soufflé rises beautifully.

But in the real world, your kitchen isn't perfect. The oven temperature fluctuates (parameter uncertainty), and there's a draft coming from the window that cools the batter (decoherence/noise). If you try to bake using a recipe designed for a "perfect, sealed, temperature-controlled oven," your soufflé will likely collapse or turn out flat.

This is the problem scientists face with quantum computers. They are incredibly powerful but also incredibly fragile. The "soufflés" (quantum states) they try to create are easily ruined by tiny errors and environmental noise.

The Old Way: The "Perfect Kitchen" Chef

For years, scientists used a method called Closed-GRAPE. Think of this as a chef who is a genius at baking, but only if the kitchen is perfect.

• How it works: The chef calculates the exact movements needed to make the soufflé rise, assuming the oven is at exactly 350°F and there is zero wind.
• The Problem: When the chef tries to use these instructions in a real, drafty kitchen, the soufflé fails. The instructions are too sensitive to the imperfections.
• The Cost: To make the instructions robust, the chef would have to simulate every possible draft and temperature fluctuation. This is like trying to calculate the trajectory of a ball while accounting for every single gust of wind in the atmosphere. It's so computationally heavy that it takes forever, like trying to solve a Rubik's cube while juggling.

The New Way: The "Adaptive" Chef

The paper introduces a new method called Approximate Open-GRAPE. This is like a chef who knows how to bake in a messy kitchen.

• The Innovation: Instead of ignoring the noise or trying to calculate every single possible disaster (which is too slow), this new algorithm makes a clever shortcut. It assumes the noise is "small" and calculates the average effect of the chaos.
• The Analogy: Imagine you are walking through a crowded, noisy market to get to a specific shop.
  • Closed-GRAPE tries to map out a path that avoids every single person perfectly, but if one person moves unexpectedly, you crash.
  • Open-GRAPE tries to map a path that avoids the crowd on average. It knows people will bump into you, so it builds a path that is slightly wider and more flexible, ensuring you still reach the shop even if you get jostled.
• The Result: This new method is almost as fast as the old "perfect kitchen" method, but it produces results that actually work in the real, noisy world.

What Did They Prove?

The team tested this on a real quantum computer (a superconducting circuit that looks like a tiny, frozen electronic city).

1. The Test: They tried to perform a specific quantum "dance" (a gate operation) to move information from one part of the computer to another.
2. The Outcome:
   • The old method (Closed-GRAPE) produced a "perfect" dance on paper, but in the real machine, it was sloppy and error-prone (about 1.44% error).
   • The new method (Approximate Open-GRAPE) produced a dance that was incredibly precise, with an error rate of only 0.60%.
3. The "Yield": Imagine you are trying to hit a bullseye with a dart.
   • With the old method, you might have to throw 1,000 darts to get one that hits the bullseye.
   • With the new method, you hit the bullseye 462 times out of 1,000 throws. That is a 340-fold improvement in success rate!

Why Does This Matter?

Quantum computers promise to solve problems that are impossible for today's supercomputers, like designing new medicines or cracking complex codes. But to do that, they need to be fault-tolerant—meaning they can keep working even when things go wrong.

This new algorithm is like a universal translator between the ideal world of math and the messy world of reality. It allows engineers to:

• Save Time: They don't need to wait days to calculate the perfect pulse; they can do it quickly.
• Save Money: They can get better results from the same hardware without needing to build even more expensive, perfect machines.
• Scale Up: It makes it possible to control larger, more complex quantum systems (like those with 20 or more qubits) using standard computers, rather than needing a supercomputer just to figure out the controls.

The Bottom Line

This paper is a breakthrough in quantum control. It's the difference between a pilot who can only fly in a windless simulator and a pilot who can land a plane safely in a thunderstorm. By teaching the computer how to "dance" with the noise rather than fighting against it, we are one big step closer to building reliable, practical quantum computers that can change the world.

Technical Summary

Here is a detailed technical summary of the paper "Robust and optimal control of open quantum systems."

1. Problem Statement

Quantum technologies (computation, communication, sensing) rely on high-fidelity coherent manipulation of quantum states. However, practical experimental platforms face two major limitations that degrade performance:

1. Parameter Uncertainties: Hardware miscalibration, sample aging, and environmental drifts cause fluctuations in system Hamiltonian parameters (coherent errors).
2. Decoherence: Inevitable coupling between the system and external reservoirs leads to energy relaxation and dephasing (incoherent errors).

Existing optimal control algorithms, such as the standard GRAPE (Gradient Ascent Pulse Engineering) algorithm, are primarily designed for closed quantum systems. They optimize control pulses based on the Schrödinger equation, ignoring environmental noise and parameter variations.

• Closed-GRAPE: Computationally efficient ($O(d^2)$ for state vectors) but produces pulses that are fragile when applied to real, open systems.
• Open-GRAPE: Attempts to optimize for open systems using the Lindblad master equation (density matrices). While accurate, it requires calculating the evolution of $d \times d$ matrices, leading to a computational complexity of at least $O(d^3)$ or $O(d^6)$. This makes it prohibitively expensive for high-dimensional systems (e.g., bosonic modes or multi-qubit registers).

The Core Challenge: There is a lack of a numerically efficient algorithm that can simultaneously account for both parameter uncertainties and decoherence to generate robust control pulses for open quantum systems without incurring the high computational cost of full density matrix simulations.

---

2. Methodology: Approximate Open-GRAPE

The authors propose a new algorithm termed Approximate Open-GRAPE. This method bridges the gap between the efficiency of Closed-GRAPE and the robustness of Open-GRAPE by utilizing a perturbative approach.

Key Theoretical Innovations:

• Perturbative Expansion: The algorithm assumes weak noise ($\kappa_m T \ll 1$) and small parameter uncertainties ($(\sigma_f T)^2 \ll 1$). Under these conditions, the evolution of the open system is expanded to the first order.
• Objective Function Construction: Instead of solving the full Lindblad master equation, the algorithm constructs an objective function ($J_{open}$) that approximates the average fidelity of the open system:
  $$J_{open} \approx J_{close} + J_d + J_f$$
  • $J_{close}$: The standard fidelity term for the ideal closed system.
  • $J_d$: A term representing fidelity loss due to decoherence (Lindblad jump operators), calculated as a sum over trajectories.
  • $J_f$: A term representing fidelity loss due to parameter uncertainty (fluctuating Hamiltonians), calculated based on the variance of the uncertain parameters.
• Trajectory-Based Gradient Calculation: Crucially, the algorithm avoids calculating the full density matrix. It computes the gradients of $J_{open}$ using state vectors (trajectories) similar to Closed-GRAPE.
  • It propagates forward and backward state vectors to evaluate the impact of noise and uncertainty.
  • This allows the algorithm to circumvent the numerical differentiation of the master equation and the expensive $O(d^3)$ matrix exponentials required by traditional Open-GRAPE.

Computational Complexity:

• Closed-GRAPE: $O(d^2)$ per iteration (using matrix-vector exponentiation).
• Approximate Open-GRAPE: $O(d^2)$ per iteration, but with a larger constant prefactor.
  • The complexity scales linearly with the number of uncertain parameters ($f$) and noise sources ($v$).
  • Theoretical analysis shows the runtime is only a constant factor (e.g., ~6.77x in their specific simulation setup) slower than Closed-GRAPE, rather than the cubic or higher scaling of full Open-GRAPE.

---

3. Key Contributions

1. Algorithmic Breakthrough: Development of the Approximate Open-GRAPE algorithm, which is the first numerically efficient method to directly optimize control pulses for open quantum systems considering both Hamiltonian uncertainties and decoherence.
2. Scalability: Demonstrated that the algorithm maintains the $O(d^2)$ scaling of state-vector methods, making it feasible to optimize control for high-dimensional systems (up to $d \approx 10^6$, equivalent to ~20 qubits) on personal computers.
3. Yield Enhancement: Showed that the algorithm significantly increases the "yield" (the probability of finding a high-quality pulse from random initial guesses) compared to Closed-GRAPE.
4. Experimental Validation: Successfully implemented and verified the algorithm on a superconducting quantum circuit consisting of a 3D microwave cavity and a transmon qubit.

---

4. Results

Numerical Simulations:

• System: A bosonic mode (cavity) coupled to an ancillary transmon qubit.
• Performance:
  • Closed-GRAPE: Produced pulses with an average infidelity of 1.47% when tested against the full Lindblad master equation (including noise).
  • Approximate Open-GRAPE: Produced pulses with an average infidelity of 0.97%.
  • Yield Improvement: The probability of generating a pulse with infidelity < 0.93% (3$\sigma$ below the Closed-GRAPE mean) increased from 0.135%** (0 out of 500) for Closed-GRAPE to 46.2% (231 out of 500) for Approximate Open-GRAPE. This represents a **>340-fold increase in yield.
  • Robustness: The algorithm maintained superior performance even when noise strengths were scaled up or down, indicating robustness against calibration errors.

Experimental Verification:

• Setup: Superconducting circuit with a high-quality factor cavity ($Q \approx 4.9 \times 10^7$) and a transmon qubit.
• Tasks: Encoding/decoding of binomial bosonic codes and logical $R_y(\pi)$ gates.
• Key Metrics:
  • Initialization/Decoding: Approximate Open-GRAPE reduced average infidelity from 1.84% (Closed-GRAPE) to 1.01%.
  • Logical Gates: The best pulses achieved an ultra-low infidelity of 0.60% (compared to 1.44% for Closed-GRAPE).
  • Repetitive Gates: In a sequence of repeated logical gates, the Approximate Open-GRAPE pulses showed a relative improvement of ~19% in infidelity, with the best result reaching 0.44%.
• Conclusion: The experimental results confirmed that the algorithm effectively suppresses the impact of both decoherence and parameter fluctuations, achieving fidelities close to the theoretical lower bound for the given hardware.

---

5. Significance

• Practical Quantum Control: This work provides a practical tool for experimentalists to generate robust control pulses that are ready for real-world hardware, which is inherently noisy and imperfect.
• Resource Efficiency: By reducing the number of optimization trials required to find high-fidelity pulses (due to higher yield), the algorithm saves significant experimental time and computational resources.
• Fault Tolerance: The ability to push infidelities lower (e.g., below 0.60%) is critical for reaching the thresholds required for quantum error correction (QEC) and fault-tolerant quantum computing.
• Generalizability: While demonstrated on superconducting circuits, the method is platform-agnostic and applicable to other quantum systems, including trapped ions, Rydberg atoms, and NV centers.
• Future Outlook: The authors note that while the algorithm handles Markovian noise well, future work will focus on extending these techniques to handle low-frequency and non-Markovian noise, further enhancing the robustness of quantum technologies.

In summary, the paper presents a pivotal advancement in quantum control theory, offering a computationally tractable solution to the "open system" problem that directly translates to improved experimental performance in leading quantum hardware platforms.