Pulse Quality Optimisation in Quantum Optimal Control

This paper introduces GECKO, a model-agnostic method that leverages the Riemannian geometry of the special unitary group to optimize control pulse quality—such as smoothness, robustness, and duration—without compromising the fidelity of the target unitary evolution.

The Gist

Imagine you are trying to teach a very delicate, high-speed dancer (a quantum computer) to perform a specific routine (a logic gate). In the world of quantum physics, this routine is defined by a series of precise "pulses" of energy, like laser beams or radio waves, that nudge the dancer into the right moves.

For a long time, scientists have been very good at finding a set of pulses that gets the dancer to the exact right pose at the end of the routine. This is called "high fidelity." However, just because the dancer hits the final pose doesn't mean the journey there was practical. The path might involve:

• Jerky, unnatural movements that are hard for the stage lights (hardware) to follow.
• Spinning too fast, which causes the dancer to get dizzy (noise sensitivity).
• Using a frequency of music that the speakers can't actually play (bandwidth limits).
• Taking a scenic, winding route when a straight line would have been faster.

The Problem:
Traditional methods try to fix all these issues while they are figuring out the routine. But this is like trying to design a perfect dance, a perfect stage, and a perfect lighting rig all at the same time. It's incredibly difficult, and often, the "perfect" routine they find is impossible to actually perform in a real lab.

The Solution: GECKO
The authors of this paper, Dylan Lewis and Roeland Wiersema, introduce a new method called GECKO (Geometric Quantum Control with Kernel Optimisation).

Think of GECKO as a two-step process:

1. Step 1: Get the Pose Right. First, use any standard method to find any set of pulses that gets the quantum computer to the correct final state with high accuracy. Don't worry if the path is jerky or weird; just make sure the dancer ends up in the right spot.
2. Step 2: Polish the Dance. Now, here is the magic. GECKO looks at that "good enough" routine and asks: "Can we change the steps without changing the final pose?"

How it Works (The Analogy):
Imagine the quantum computer's state is a point on a smooth, curved hill (a mathematical shape called a manifold). The "final pose" is a specific spot on that hill.

• There are many different paths you can walk to get to that spot. Some paths are steep and rocky; others are smooth and flat.
• Standard methods try to find the best path from the very bottom of the hill.
• GECKO says: "We are already at the top. Let's walk around the peak."

GECKO uses advanced geometry to find "flat directions" on the hill. If you walk in these specific directions, you stay at the exact same height (the fidelity remains perfect), but you change the shape of your path. It's like walking around the rim of a crater; you stay at the same elevation, but you can choose to walk on a smooth, paved path instead of a jagged, rocky one.

By walking along these "flat directions," GECKO can:

• Smooth out the dance: Turn jerky, sudden jumps into gentle curves that are easier for hardware to handle.
• Filter the music: Remove high-pitched notes (frequencies) that the speakers can't play, without changing the melody.
• Make it robust: Adjust the steps so that if the dancer stumbles slightly (due to noise or errors), they still land in the right spot.
• Speed it up: Find a shorter path to the same destination, making the gate faster.

The Results:
The authors tested this on a simulated quantum system (a pair of "qubits" acting like a tiny magnet system). They started with a standard solution and then used GECKO to improve it.

• They successfully removed high-frequency noise from the pulses.
• They smoothed out jagged control signals.
• They made the system much more resistant to errors.
• They significantly shortened the time it took to perform the gate.

The Bottom Line:
GECKO is a tool that separates the job of "getting the answer right" from the job of "making the answer practical." It takes a mathematically perfect but experimentally messy solution and refines it into a smooth, robust, and hardware-friendly version, all while guaranteeing the final result remains exactly the same. It's like taking a rough draft of a novel and polishing the prose without changing the plot.

Technical Summary

1. Problem Statement

Quantum optimal control (QOC) aims to design experimental control pulses (e.g., laser amplitudes, phases) that implement a target unitary evolution with high fidelity. While standard methods like GRAPE, Krotov, and CRAB can find high-fidelity solutions, these solutions often fail to meet practical experimental constraints or secondary quality objectives.

• The Gap: Standard QOC often treats all constraints (bandwidth, smoothness, robustness, duration) simultaneously during the search for a high-fidelity pulse. This can lead to:
  • Artificial traps in the control landscape.
  • Slow convergence.
  • Solutions that are mathematically optimal for fidelity but experimentally difficult to implement (e.g., containing high-frequency noise or abrupt discontinuities).
• The Opportunity: There are often many distinct control pulses that achieve the same target unitary with comparable fidelity. The authors propose a strategy to first find any high-fidelity solution and then traverse the corresponding fidelity level set to optimize secondary pulse qualities (like smoothness or robustness) without sacrificing the primary fidelity goal.

2. Methodology: GECKO

The authors introduce GEometric Quantum Control with Kernel Optimisation (GECKO), a model-agnostic post-processing method.

Core Concept

GECKO exploits the Riemannian geometry of the special unitary group $SU(N)$ (where $N=2^n$ for $n$ qubits). It identifies directions in the pulse parameter space that leave the implemented unitary unchanged to the first order.

Mathematical Formulation

1. Pulse Representation: A pulse is defined by parameters $\Phi$ consisting of $L$ time steps and $K$ control generators. The total unitary is $U_G(\Phi)$.
2. Fidelity Constraint: A solution is valid if $F(\Phi, U_{target}) > 1 - \epsilon$.
3. Kernel Identification:
   • The authors define a Jacobian map $J(\Phi)$ that maps tangent vectors in the parameter space ($T_\Phi \mathbb{R}^{LK}$) to the tangent space of the unitary group ($T_{U_G} SU(N)$).
   • They identify the nullspace (kernel) of this Jacobian, $\text{ker}(J(\Phi))$.
   • Any update $\delta \Phi$ lying in this kernel results in $U_G(\Phi + \delta \Phi) = U_G(\Phi) + O(\|\delta \Phi\|^2)$. Thus, moving along the kernel preserves the unitary (and fidelity) to the first order.
4. Optimization Strategy:
   • The kernel is spanned by an orthonormal basis $Z(\Phi)$.
   • Updates are parameterized as $\delta \Phi = Z(\Phi)x$, where $x$ are new coordinates.
   • The algorithm minimizes a secondary quality function $Q(\Phi)$ (e.g., smoothness, spectral content) subject to the constraint that updates remain within the kernel.
   • Algorithm Loop:
     1. Compute Jacobian $J(\Phi)$ and its kernel basis $Z(\Phi)$.
     2. Project the gradient of the quality function $\nabla Q$ onto the kernel (or solve a least-squares problem in kernel coordinates).
     3. Update parameters $\Phi \leftarrow \Phi + s \cdot \text{normalized\_update}$.
     4. If fidelity drops below the threshold due to second-order errors, re-optimize using a standard QOC method (like GEOPE) to restore fidelity, then resume GECKO.

3. Key Contributions

• Decoupling Fidelity and Quality: GECKO separates the task of finding a high-fidelity pulse from optimizing its experimental properties. This avoids the "hard constraints" problem where experimental limitations prevent finding a solution at all.
• Geometric Traversal: It provides a rigorous geometric framework (using the Jacobian nullspace) to traverse the control landscape level sets, ensuring that secondary optimizations do not degrade the primary unitary implementation.
• Model Agnosticism: The method is not tied to a specific Hamiltonian or control hardware; it only requires the ability to compute the Jacobian and the gradient of a differentiable quality function.

4. Results and Numerical Demonstrations

The authors tested GECKO on a transverse-field Ising Hamiltonian for two-qubit systems, targeting CZ and CNOT gates.

• A. Frequency-Domain Filtering:
  • Goal: Remove high-frequency components (low-pass) or enhance specific frequencies without changing the gate.
  • Result: GECKO successfully suppressed high-frequency noise and shaped the spectrum (low-pass, high-pass, band-stop) while maintaining infidelity $< 10^{-6}$.
• B. Pulse Smoothing:
  • Goal: Reduce "roughness" (abrupt changes in control parameters) to minimize noise susceptibility and bandwidth requirements.
  • Result: GECKO produced significantly smoother pulses than standard Gaussian filtering. Crucially, GECKO could globally suppress unnecessary control channels (e.g., eliminating the need for a second control field entirely) to maximize global smoothness, a feat Gaussian filters could not achieve.
• C. Noise Robustness:
  • Goal: Optimize pulses to be robust against parameter deviations (e.g., amplitude errors).
  • Result: By optimizing a worst-case fidelity objective over a perturbation range, GECKO found pulses that maintained high fidelity even with significant parameter shifts ($\delta \approx 0.05$), outperforming initial solutions.
• D. Pulse Duration (Time-Optimality):
  • Goal: Minimize the time required to execute the gate.
  • Result:
    • Geometric Path Length: GECKO minimized the path length on the $SU(N)$ manifold, finding a duration of $T \approx 2.323/g$.
    • Drift-Limited Time: When minimizing time subject to a fixed drift coupling, GECKO found a much shorter duration ($T \approx 0.854/g$), though this required larger control amplitudes.

5. Significance and Future Implications

• Experimental Viability: GECKO bridges the gap between theoretical high-fidelity control and practical hardware constraints. It allows experimentalists to take a "good enough" solution and refine it for their specific hardware limitations (bandwidth, smoothness, robustness).
• Complexity Geometry: The method offers a numerical approach to solving geodesic equations in sub-Riemannian manifolds, which is relevant to understanding quantum circuit complexity and the minimum time required for quantum operations.
• Scalability: While the current implementation scales as $O(LKN^4)$ (due to Jacobian and SVD computations), making it feasible for small systems ($\lesssim 5$ qubits), the authors note that exploiting symmetries or sparsity could extend its utility to larger systems.
• Flexibility: The framework allows for the simultaneous optimization of multiple objectives (e.g., smoothing + robustness) by defining a weighted sum quality function.

In summary, GECKO represents a paradigm shift in quantum control design: rather than struggling to satisfy all constraints simultaneously during the search, it finds a high-fidelity solution first and then "polishes" it using the geometric freedom inherent in the control landscape.