Optimizing continuous-time quantum error correction for arbitrary noise

Technical Summary: Optimizing Continuous-Time Quantum Error Correction for Arbitrary Noise

Problem Statement
Quantum systems are inherently susceptible to environmental decoherence, necessitating Quantum Error Correction (QEC). While standard stabilizer codes offer a robust framework for correcting independent Pauli errors, they often prove suboptimal for complex, realistic noise environments. Real-world noise can be non-Markovian, cause leakage out of the computational subspace, introduce non-Pauli errors, or exhibit spatial and temporal correlations. Furthermore, the standard discrete-time QEC model assumes instantaneous recovery, whereas in practice, noise is perpetual. This motivates the framework of Continuous-Time Quantum Error Correction (CT-QEC), where weak noise and weak recovery operations occur simultaneously.

A critical challenge in CT-QEC is the selection of measurement observables and recovery operators. Unlike discrete QEC, where different measurement bases may yield equivalent performance, the choice of weak measurement basis and corresponding weak unitary corrections in CT-QEC significantly impacts performance. For instance, weakly measuring stabilizers and applying weak Pauli corrections may result in suboptimal fidelity compared to other measurement-correction pairs. Identifying the optimal recovery strategy for arbitrary, device-level noise channels remains a difficult optimization problem, particularly because the space of possible code spaces (subspaces) forms a non-convex Grassmannian manifold.

Methodology
The authors propose a machine learning (ML) protocol to simultaneously optimize the quantum error-correcting code space and the corresponding weak recovery channel within the CT-QEC framework. The approach treats the noise channel as an arbitrary completely-positive and trace-preserving (CPTP) map, allowing for correlations in both space and time.

1. Neural Network Architecture: The optimization utilizes a Multilayer Perceptron (MLP) with six hidden layers (128 neurons each, ReLU activation). The network takes a representation of the code space as input and outputs a set of complex matrices that define the recovery channel.
2. Parameterization of Recovery Channels: Since the set of CPTP maps is convex, the output layer is parameterized to generate Kraus operators. The network produces arbitrary complex matrices $\{G_j\}$, which are normalized to form valid Kraus operators $\{R_j\}$ for a strong channel $R$. The weak recovery channel $\tilde{R}$ is then constructed via a convex combination with the identity channel: $\tilde{R} = (1-\epsilon^2)I + \epsilon^2 R$, where $\epsilon = \sqrt{\kappa \delta t}$.
3. Optimization of Code Space: The set of all code subspaces forms the Grassmannian manifold, which is non-convex. To navigate this, the authors employ a Riemannian gradient descent algorithm. The Euclidean gradient of the cost function is projected onto the tangent space of the manifold at the current point. The update step involves moving along a straight line in the embedding space and retracting back onto the manifold using the polar decomposition (via singular value decomposition), avoiding the computational expense of exponential maps.
4. Cost Functions:
   • Markovian Noise: The objective is to minimize the infidelity between the initial maximally entangled state $|\Phi\rangle_{LR}$ and the state after a short time $\delta t$, subject to noise and a strong recovery map. This prevents the trivial solution of the identity map and ensures the code protects logical states longer than bare physical qubits.
   • Non-Markovian Noise: For time-correlated noise, the cost function minimizes the time-averaged infidelity over an ensemble of noise and recovery trajectories.

Key Results
The protocol was tested on various noise models, comparing the ML-optimized code and recovery against standard stabilizer codes and bare qubits:

• Markovian Bit-Flip Noise: For three qubits subject to uniform bit-flip noise, the neural network rediscovered the standard $[[3, 1, 3]]$ bit-flip code, empirically confirming its optimality for this symmetric noise.
• Amplitude Damping and Correlated Dephasing: For five qubits encoding one logical qubit under amplitude damping and spatially correlated dephasing, the ML approach significantly outperformed both the standard $[[5, 1, 3]]$ code and a modified version tailored to specific error syndromes.
• Leakage Errors: In a system with two physical qubits where leakage occurs to an external state, the ML-optimized recovery successfully mitigated leakage errors, outperforming unencoded physical qubits.
• Qutrit Systems: The method successfully encoded a logical qubit into two physical qutrits, demonstrating flexibility beyond qubit-based systems.
• Non-Markovian Noise:
  • For $1/f$ noise (continuous-time Hamiltonian rotations), the ML-optimized code and recovery significantly outperformed the Bacon-Shor code and bare qubits.
  • For constant Hamiltonian errors (a highly non-Markovian model), the code trained on $1/f$ noise generalized well, outperforming the $[[4, 1, 1, 2]]$ code and bare qubits without specific retraining, suggesting robustness against overfitting.

Significance and Claims
The paper claims that this ML-driven approach enables the discovery of recovery schemes and code spaces tailored specifically to arbitrary device-level noise, including non-Markovian and correlated errors where standard stabilizer codes are suboptimal. By leveraging the continuous-time regime, the method exploits the quantum Zeno effect to suppress non-Markovian noise by truncating the bath's memory kernel through frequent measurements.

The authors emphasize that while the resulting Kraus operators are arbitrary and may be non-local or difficult to implement physically, the framework provides a theoretical upper bound and a design tool. They suggest that device-level coupling information could be incorporated into the loss function in future work to enhance practicality. The protocol is presented as a method to engineer codes for small systems, which could subsequently be concatenated with standard codes to achieve higher levels of error correction. The work does not claim immediate experimental realization but rather establishes a computational framework for optimizing CT-QEC strategies.