Singularity-free dynamical invariants-based quantum control

This paper introduces a generalized, singularity-free invariant-based protocol that transforms finite-dimensional quantum state preparation into an equivalent single-qubit problem to synthesize smooth, hardware-feasible control fields capable of achieving high-fidelity results in both characterized and uncharacterized non-Markovian open quantum systems.

The Gist

Imagine you are trying to steer a very delicate, invisible boat (a quantum system) from a starting dock to a specific destination island. The problem is that the ocean is full of unpredictable, chaotic waves (noise) that can push your boat off course. In the quantum world, if you get pushed off course even slightly, your "cargo" (the information or state) is ruined.

This paper presents a new, robust navigation system to get that boat to the island perfectly, even in a stormy, non-Markovian ocean (where the waves have memory and don't just behave randomly).

Here is how the authors' method works, broken down into simple concepts:

1. The Problem with Old Maps (The "Singularity" Issue)

Previous methods for steering these quantum boats used a technique called "inverse engineering." Think of this like trying to draw a map backward: you know where you want to end up, so you calculate the path you must have taken to get there.

However, the old maps had a fatal flaw: they often led to "singularities." In everyday terms, this is like a GPS telling you to turn 90 degrees instantly, or accelerate to infinite speed, or dive straight into the ocean floor. These instructions are physically impossible to follow. If a control pulse (the steering command) tries to go to "infinity," the hardware breaks or the experiment fails.

2. The New Strategy: The "Safe Path" Protocol

The authors introduce a new way to draw the map that guarantees the boat never hits a cliff or needs to move at infinite speed. They do this in three main steps:

Step A: Simplify the Ocean (The SU(2) Subspace)

If you are steering a massive, complex ship (a high-dimensional quantum system), it's hard to calculate the perfect path. The authors say, "Let's pretend this big ship is actually just a small, simple dinghy."
They mathematically shrink the problem down to a two-dimensional "subspace" (like a flat sheet of paper) that contains both the start and the finish. They prove that if you can steer the dinghy perfectly on this sheet, you can map those exact instructions back to the big ship. It's like solving a puzzle on a napkin and then applying the solution to a giant mural.

Step B: The "No-Cliff" Detour (Trajectory Splitting)

Even on the small dinghy, the old maps sometimes demanded impossible turns. The authors' secret sauce is splitting the journey.
Instead of trying to draw one long, smooth line from Start to Finish, they break the trip into smaller segments (sub-trajectories).

• The Analogy: Imagine driving a car. If you need to turn 180 degrees, you can't do it in one sharp, impossible jerk. Instead, you drive forward, make a gentle turn, drive a bit more, and make another gentle turn.
• The Result: By breaking the path into smaller pieces and choosing a different "reference direction" for each piece, they ensure that the steering commands (the control pulses) never become infinite. They remain smooth, finite, and physically possible to build with real hardware.

Step C: The "Storm-Proofing" Layer (Noise Mitigation)

Now that they have a family of safe paths that work in calm water (no noise), they need to handle the storm.

• Scenario 1: We know the storm. If they know exactly how the waves behave (the noise model), they use math to pick the specific path from their "family of paths" that naturally cancels out the waves. It's like choosing a route that rides the swells rather than fighting them.
• Scenario 2: We don't know the storm. If the waves are mysterious and unpredictable, they use Machine Learning. They train a computer model (a "graybox" AI) by simulating many different paths and seeing how the boat reacts. The AI learns to predict which path will stay on course best, even without a perfect mathematical description of the noise.

3. The Results: A Smooth Ride

The authors tested this on computers (simulations) with:

• Single qubits (the basic units of quantum computers).
• More complex systems (like "qutrits" which have three states, and two-qubit systems).
• Different types of noisy environments, including "colored noise" (waves that have a pattern/memory).

The Outcome:

• High Fidelity: The boat arrived at the island almost perfectly (high fidelity), even in the storm.
• No Crashes: The steering commands were always smooth and finite. No "infinite speed" instructions were ever generated.
• Versatility: The method worked whether they knew the noise model or had to learn it on the fly.

Summary

In short, this paper solves a major headache in quantum control. It provides a recipe to design steering commands that are:

1. Physically possible (no infinite speeds).
2. Adaptable (works for big or small quantum systems).
3. Resilient (works even when the environment is noisy and unpredictable).

It's like upgrading from a navigation system that sometimes tells you to drive through a mountain, to one that always finds a smooth, drivable road, even if the weather is terrible.

Technical Summary

Technical Summary: Singularity-free Dynamical Invariants-based Quantum Control

Problem Statement
State preparation is a fundamental prerequisite for quantum technologies, yet achieving high-fidelity control in non-Markovian open quantum systems remains a significant challenge. Existing invariant-based inverse engineering methods, which utilize Lewis-Riesenfeld dynamical invariants to synthesize analytic control fields, suffer from two primary limitations. First, standard parameterizations often yield control pulses with singularities (amplitudes diverging to infinity), rendering them experimentally infeasible. Second, these methods are largely restricted to closed systems or those governed by Markovian noise (Lindblad form), failing to address the memory effects and model uncertainties inherent in realistic non-Markovian environments.

Methodology
The authors propose a generalized, singularity-free protocol for finite-dimensional state preparation under arbitrary noise conditions. The methodology proceeds through the following stages:

1. Dimensionality Reduction via SU(2) Subspace:
   For a $d$-dimensional qudit system, the control problem is transformed into an equivalent single-qubit problem. An SU(2) subspace is constructed using the initial state $|\psi_{in}\rangle$ and the component of the target state orthogonal to it. By restricting the dynamics to this subspace and defining equivalent Pauli operators, the complexity of the control problem is drastically reduced while maintaining full control over the target state.

2. Singularity-Free Trajectory Design:
   To eliminate singularities, the evolution trajectory between the initial and target states is split into multiple subtrajectories. The choice of a "reference axis" (the axis along which the control amplitude is fixed) is dynamically switched between subtrajectories based on the location of the target state on the Bloch sphere. This ensures that the denominator in the control pulse equations (derived from the invariant coefficients) never vanishes. Specifically, the protocol enforces that the reference control amplitude $h_3(t)$ maintains a consistent sign across each subtrajectory, preventing the invariant coefficient $f_3(t)$ from crossing zero.

3. Invariant Parameterization and Bounding:
   Within each subtrajectory, the invariant coefficients are parameterized as polynomials. The coefficients are constrained to satisfy boundary conditions (commutation with the Hamiltonian at endpoints) and a normalization constraint. Free parameters within these polynomials are bounded to ensure the invariant remains real and non-vanishing, guaranteeing that the resulting control pulses are finite and continuous.

4. Noise Mitigation Strategies:
   The protocol addresses noise through two distinct approaches to select the optimal pulse from the generated family:

   • Known Noise (Whitebox): If the noise model is known, an analytical cost function (infidelity) is minimized using perturbative expansions (e.g., Dyson series) to find the pulse that minimizes noise impact.
   • Unknown Noise (Graybox): If the noise is uncharacterized or intractable, a machine learning (ML) module is embedded. A "graybox" architecture combines a blackbox neural network (learning the mapping from pulse parameters to noise operator matrix elements) with a whitebox layer (computing physical expectations). This model is trained on experimental data to predict system behavior, allowing for optimization without a priori noise models.

Key Contributions

• Singularity-Free Guarantee: The paper rigorously proves that by splitting the trajectory and bounding the free parameters, the resulting control pulses are guaranteed to be bounded ($h(t) < \infty$) for all time, overcoming a major limitation of previous invariant-based methods.
• Generalized Non-Markovian Control: The framework extends invariant-based control beyond Lindblad dynamics to arbitrary non-Markovian noise, including classical colored noise and quantum bath interactions, without requiring simplifying approximations.
• Finite-Dimensional Extension: The method provides a generic approach to control arbitrary finite-dimensional systems by mapping them to an SU(2) subspace, rather than being restricted to specific system dimensions or fixed subspaces.
• Hybrid Optimization Framework: The integration of model-based control (whitebox) and data-driven ML (graybox) allows for robust state preparation even when noise characteristics are partially or completely unknown.

Results
Numerical simulations demonstrate the efficacy of the protocol across various scenarios:

• Qubit Systems: The method successfully prepares ground states for six different target Hamiltonians under multi-axis Random Telegraph Noise (RTN). The optimized pulses (both whitebox and graybox) achieved fidelities significantly higher than the average and worst-case pulses in the generated dataset, often exceeding 95% fidelity even in the presence of strong non-Markovian noise.
• Qudit Systems: The protocol was applied to a qutrit subject to quantum noise and a two-qubit system. In the qutrit case, the method achieved high fidelity despite the complexity of the noise model. For the two-qubit system, the protocol successfully generated control fields to prepare a Bell state, demonstrating the scalability of the SU(2) subspace mapping.
• Pulse Characteristics: The resulting control waveforms were smooth, continuous, and hardware-feasible, with no singularities observed.

Significance and Claims
The authors claim that this work fills a critical gap in the literature by providing a versatile, singularity-free framework for invariant-based control in realistic open-system regimes. The method offers a robust route toward quantum state engineering on Noisy Intermediate-Scale Quantum (NISQ) hardware and other platforms exhibiting non-Markovian dynamics. By avoiding the need for global optimization over a vast control landscape (as in GRAPE) and instead constructing families of analytically valid pulses, the approach ensures boundary conditions are met exactly while allowing for the selection of optimal pulses based on robustness criteria. The integration of machine learning further enhances adaptability to complex, partially unknown noise environments, making the protocol a practical tool for analog quantum optimization and state preparation on noisy platforms.