Robust Quantum Control against Clock Noises in Multi-Qubit Systems

TL;DR

This paper addresses the challenge of clock noise in multi-qubit quantum control by deriving an error estimation formula, proposing optimization algorithms for robustness, and demonstrating their effectiveness through simulations.

Contribution

It introduces a quantitative measure for control robustness against clock noises and develops two optimization algorithms, homotopic and b-GRAPE, to enhance robustness in quantum control.

Findings

Both algorithms significantly improve robustness against clock noises.

Homotopic algorithm converges faster.

b-GRAPE achieves more robust controls.

Abstract

High-precision manipulation of multi-qubit quantum systems requires strictly clocked and synchronized multi-channel control signals. However, practical Arbitrary Waveform Generators (AWGs) always suffer from random signal jitters and channel latencies that induces non-ignorable state or gate operation errors. In this paper, we analyze the average gate error caused by clock noises, from which an estimation formula is derived for quantifying the control robustness against clock noises. This measure is then employed for finding robust controls via a homotopic optimization algorithm. We also introduce our recently proposed stochastic optimization algorithm, b-GRAPE, for training robust controls via randomly generated clock noise samples. Numerical simulations on a two-qubit example demonstrate that both algorithms can greatly improve the control robustness against clock noises. The homotopic algorithm converges much faster than the b-GRAPE algorithm, but the latter can achieve more robust controls against clock noises.

Figures

Equations

$$H(t)=H_0+\sum _{k=1}^m{u}_k(t)H_k,$$

$$u_k(t)=u_k^j,t_k^{j-1}\le t\le t_k^j,j=0,1,\cdots ,M,$$

$$\delta t_k^j=t_k^j-{\bar{t}}_k^j={\tau }_k+{\xi }_k^j,$$

$${\bar{u}}_k(t)=u_k^j,{\bar{t}}_{j-1}\le t\le {\bar{t}}_j,j=0,1,\cdots ,M,$$

$$i\dot{\bar{U}}(t)=\bar{H}(t)\bar{U}(t)=\left[H_0+\sum _{k=1}^m{\bar{u}}_k(t)H_k\right]\bar{U}(t).$$

$$i\dot{\Delta }(t)=H(t)\Delta (t)+\sum _{k=1}^m\delta u_k(t)H_k\bar{U}(t),$$

$$\delta u_{k}(t)=\left\{\begin{array}[]{ll}\delta u_{k}^{j},&\bar{t}_{k}^{j}<t<t_{k}^{j}\\ 0,&{\rm else}\end{array}\right.$$

$$\Delta (T)$$

$$U(\tau )\approx \bar{U}(\tau )\approx \bar{U}({\bar{t}}_k^j),\forall \tau \in [{\bar{t}}_k^j,t_k^j],$$

$$\Delta (T)\approx -iU(T)\sum _{k=1}^m\sum _{j=1}^M\delta t_k^j\delta u_k^j{\bar{H}}_k^j,$$

$$\Vert \Delta (T){\Vert }_F^2\approx \sum _{k,k^{\prime }}\sum _{j,j^{\prime }}\delta t_k^j\delta t_{k^{\prime }}^{j^{\prime }}\delta u_k^j\delta u_{k^{\prime }}^{j^{\prime }}\cdot \mathrm{tr}\left({\bar{H}}_k^j{\bar{H}}_{k^{\prime }}^{j^{\prime }}\right).$$

$$J_{\mathrm{N}}[\mathbf{u}]=⟨\Vert \Delta (T){\Vert }_F^2⟩$$

$$\Vert \delta \text{u}{\Vert }^2=\sum _{j=1}^M|\delta u_k^j{|}^2,\delta {\text{H}}_k=\sum _{j=1}^M\delta u_k^j{\bar{H}}_k^j.$$

$$J[\text{u}]$$

$${\text{u}}^{(\ell +1)}={\text{u}}^{(\ell )}-{\alpha }_{\ell }\frac{\partial J_0}{\partial {\text{u}}^{(\ell )}},$$

$${\text{u}}^{(\ell +1)}={\text{u}}^{(\ell )}-{\alpha }_{\ell }\left[\frac{\partial J_{\mathrm{N}}}{\partial {\text{u}}^{(\ell )}}-\frac{{\left(\frac{\partial J_0}{\partial {\text{u}}^{(\ell )}}\right)}^T\frac{\partial J_{\mathrm{N}}}{\partial {\text{u}}^{(\ell )}}}{{\left(\frac{\partial J_0}{\partial {\text{u}}^{(\ell )}}\right)}^T\frac{\partial J_0}{\partial {\text{u}}^{(\ell )}}}\frac{\partial J_0}{\partial {\text{u}}^{(\ell )}}\right].$$

$$J_{\mathcal{S}}[\text{u}]=\frac{1}{N}\sum _{\mathbf{t}\in \mathcal{S}}\Vert U(T,\mathbf{t})-U_f{\Vert }^2.$$

$${\text{u}}^{(\ell +1)}={\text{u}}^{(\ell )}-{\alpha }_{\ell }\frac{\partial J_{{\mathcal{S}}^{(\ell )}}}{\partial {\text{u}}^{(\ell )}},$$

$$H(t)=g{\sigma }_{z1}{\sigma }_{z_2}+\sum _{k=1}^2[u_k(t){\sigma }_k^{+}+u_k^{\ast }(t){\sigma }_k^{-}],$$

$$C^{\tau}=\left(\begin{array}[]{cccc}0.0533&0.0533&0.0400&0.0400\\ 0.0533&0.0533&0.0400&0.0400\\ 0.0400&0.0400&0.0533&0.0533\\ 0.0400&0.0400&0.0533&0.0533\end{array}\right){\rm ns}^{2},$$

Full text

I Introduction

The multi-qubit manipulation is prevalent for quantum information processing with large-scale quantum circuits[1, 2, 3]. Towards fault-tolerant quantum computation, high precision control must be achieved above the error-correction threshold for the state and gate operations, and these have to be accomplished in presence of disturbances or uncertainties (e.g., pulse distortion, crosstalks and device noises [4]). Under such circumstances, robust single-shot controls are highly demanded so that the control precision is as insensitive as possible to the uncertainties or noises. Various algorithms have been proposed for this purpose, such as ensemble control for field inhomogeneity [5], dynamical decoupling for environmental noises [6], STIRAP for control pulse shape errors [7], DRAG algorithm for level leakages [8], detuning pulses [9, 10] for control field compensation, and sampling-based algorithms for generic parametric uncertainties in the Hamiltonian [11].

In this paper, we study robust controls against clock noises, a broadly existing but rarely considered noise source coming from clock signals in imperfect control signal generators in multi-qubit control systems. Ideally, the clock signals in different channels must be perfectly synchronized with the a common reference clock, but random timing errors always occur in realistic clock signals, especially in high-speed arbitrary waveform generators (AWG) [12, 13]. Typical clock noises include clock jitters (referred to as the timing deviation from a presumably periodic signal in relation to a reference clock signal) and channel latencies (referred to as the delay time from the AWG to the quantum chip to be controlled) [14]. The clock noises randomly alter pulse areas and thus lead to stochastic operation errors.

In state-of-art AWG devices, the clock jitters can be managed to be at picosecond scale. The channel latencies vary from system to system, which are often much longer and much uncontrollable. For now, the affection of clock noises on the control precision are thought to be less important than other error sources (e.g., decoherence), but eventually they must be considered in extremely high-precision regime after other errors are mitigated [13]. Therefore, it is deserved to study whether it is possible and how to find robust controls against clock noises.

To the authors’ knowledge, clock noises have not been considered in the design of robust control of quantum gates. Related studies can be found in classical control systems (e.g., networked control systems with communication delays [15, 16]), in which the system’s dynamics is described by an equivalent Markovian process driven by clock noises in the controller [17]. Stochastic optimal control theory can then be applied for state filtering and noise suppression  [18, 19, 20]. However, these results cannot be extended here to quantum control systems, because the required realtime feedback and communication between distributed agents are usually infeasible. Under most circumstances, one has to seek an open-loop (i.e., single-shot) robust control that is as insensitive as possible to the clock noises.

In this paper, we will first carry out a perturbation analysis on the average gate error induced by clock noises, from which an estimation formula is derived for evaluating the sensitivity of the control to clock noises. Then, two optimization algorithms are proposed for designing controls with enhanced robustness. The rest of the paper is arranged as follows. In Section II, we analyze the average gate error caused by latency and jitter noises. In Section III, we propose a deterministic homotopic algorithm and a randomized b-GRAPE algorithm for the design of robust and high-precision controls, whose effectiveness are demonstrated in Section IV via numerical simulations on a two-qubit system. Finally, conclusions are drawn in Section V.

II Modeling and Analysis of clock-noise induced errors

II.1 Quantum control in presence of clock noises

Consider a quantum control system that involves $m$ control channels, and its unitary propagator is governed by $i\dot{U}(t)=H(t)U(t)$, where $U(t)\in\mathbb{C}^{N\times N}$ represents the quantum gate operation starting from $U(0)=\mathbb{I}$. The controlled Hamiltonian reads

[TABLE]

in which $H_{0}$ and $H_{k}$’s are the free Hamiltonian and control Hamiltonians, respectively. The control fields $u_{k}(t)\in\mathbb{C}$, $k=1,\cdots,m$, are delivered to the quantum system via their respective control channels (e.g., control lines).

In most radio-frequency and microwave-based control systems, the control field generated by an arbitrary waveform generator (AWG) is prepared in piecewise-constant waveforms, i.e.,

[TABLE]

where $u_{k}^{j}$ and $t_{k}^{j}$ are the control amplitude and terminal time of the $j$th piecewise-constant control pulse of the $k$th field. Therefore, the control waveform is determined not only by the amplitude variables $\textbf{u}=\{u_{k}^{j}\}$, but also by the timing variables $\textbf{t}=\{t_{k}^{j}\}$.

When the pulses are periodically clocked and all control channels are perfectly synchronized, the timing variables ticks as $t_{k}^{j}=\bar{t}_{k}^{j}=jT_{s}$ for all $j=0,1,\cdots,M$ and $k=1,\cdots,m$, where $T_{s}$ is the sampling period of the AWG device. The timing errors are thus defined as the differences between the actual and ideal timing variables, i.e.,

[TABLE]

which consists of the latency time $\tau_{k}\geq 0$ of the $k$th control channel and random jitter noises $\xi_{k}^{j}$ at each timing instant. The mean values of the jitter variables can be reasonably assumed to be zero.

II.2 Error analysis

Throughout this paper, we assume that the amplitude variables ${\bf u}$ are precise (robust control to amplitude errors has been broadly studied in the literature, e.g., in [7]), and focus on the error caused by clock noises.

The clock noises $\delta t_{k}^{j}$ bring control errors into the quantum gate operation via the change of areas of the sub-pulses. Let

[TABLE]

be the ideally clocked control signal and $\bar{U}(t)$ the unitary propagator steered by $\bar{u}(t)$, i.e.,

[TABLE]

Then, the gate error operator $\Delta(t)=U(t)-\bar{U}(t)$ can be shown to obey the dynamical equation:

[TABLE]

where $\Delta(0)=0$ and $\delta u_{k}(t)=u_{k}(t)-\bar{u}_{k}(t)$ is the difference between the actual and the ideally clocked control field in the $k$th channel. As can be seen in Fig. 1, $\delta u_{k}(t)$ consists of the following slices of pulses:

[TABLE]

where $\delta u_{k}^{j}=u_{k}^{j-1}-u_{k}^{j}$ is the decremental control amplitude. One can immediately see that the gate error can be reduced by making $\delta u_{k}^{j}$ as small as possible, i.e., choosing slowly varying smooth control fields.

For a more accurate analysis, we can formally integrate Eq. (6) to evaluate the gate error at the final time $t=T$, as follows:

[TABLE]

In the perturbation regime, i.e., when all timing errors $\delta t_{k}^{j}$ are much smaller than the sampling period $T_{s}$, it is reasonable to take the following approximation

[TABLE]

which leads to a simplified formula:

[TABLE]

where $\bar{H}_{k}^{j}\triangleq\bar{U}^{\dagger}(\bar{t}_{k}^{j})H_{k}\bar{U}(\bar{t}_{k}^{j})$ is only dependent on the ideal system (5) but not on the clock noise. The Frobenius norm of $\Delta(T)$ can thus be expanded as

[TABLE]

Now we can quantify the robustness (or the sensitivity) of the control by the average gate error over the clock noises:

[TABLE]

where

[TABLE]

and $C^{\tau}_{kk^{\prime}}=\langle\tau_{k}\tau_{k^{\prime}}\rangle$ is the covariance between the $k$th and $k^{\prime}$th channel latencies $\tau_{k}$ and $\tau_{k^{\prime}}$, and $\mu_{0}^{2}$ is the variance of the jitter errors (assumed to follow identical distribution with zero mean).

The estimation formula (12) indicates the respective roles of the latency and jitter noises. The latency affects the average error through the first term, a complicated function of the unitary propagators, while the second term shows that the jitter noises is determined by the smoothness of the control fields characterized by $\|\delta\textbf{u}\|^{2}$.

III Robust Optimization algorithms for Clock noises

The task of robust control here is to find proper control amplitude variables $\textbf{u}=\{u_{k}^{j}\}$ that is as insensitive as possible to the clock noises ${\bf\delta t}=\{\delta t_{k}^{j}\}$ in the timing variables ${\bf t}=\{t_{k}^{j}\}$. In the following, we will propose two types of algorithms, one deterministic and one stochastic, for the design of robust and high-precision controls based on the average gate error analysis.

III.1 Deterministic homotopic algorithm

This algorithm is based on the error estimation formula (12) that quantifies the control robustness. Recall that a standard gradient algorithm (without consideration of robustness) minimizes $J_{0}[\textbf{u}]=\|\bar{U}(T)-U_{f}\|^{2}$ based on the ideal model. To improve the control robustness, it is natural to introduce (12) as a penalty term to the gate error objective as follows:

[TABLE]

where $\beta>0$ is the weight parameter. The composite objective is deterministically dependent on the control variable ${\bf u}$, in which the clock noise variables have been averaged out. Thus, it can be minimized by a gradient-descent algorithm. However, the parameter $\beta$ must be be carefully chosen for balancing the objectives $J_{0}$ and $J_{\rm N}$. Otherwise, either $J_{0}$ or $J_{\rm N}$ may be sacrificed when they conflict with each other.

To avoid the unwanted trade-off between $J_{0}$ and $J_{\rm N}$, we propose a two-stage homotopic algorithm that minimizes the two objectives separatively. In the first stage, we apply the well-known gradient-based GRAPE algorithm [21] to minimize the gate error starting from a randomly chosen initial guess on the field. This can be done, for example, by following the steepest gradient-descent direction of $J_{0}$:

[TABLE]

where $\textbf{u}^{(\ell)}$ are the control amplitudes in the $\ell$th iteration and $\alpha_{\ell}$ is the corresponding learning rate. The obtained optimal control can achieve extremely high precision, but its robustness to clock noises is not guaranteed.

In the second stage, we apply a homotopic algorithm [22, 23] that continuously reduces the value of $J_{\rm N}$ while maintaining the achieved high precision $J_{0}$. This is done by updating the control along a descending direction of $J_{\rm N}$ that is orthogonal to the gradient of $J_{0}$, which can be obtained by the following Schmidt orthogonalization:

[TABLE]

The homotopic algorithm can be efficiently carried out owing to its deterministic nature, and both the control precision (through $J_{0}$) and the robustness (through $J_{\rm N}$) can be improved without having to make a compromise. Since the algorithm is based on the perturbation analysis of the clock-noise induced gate errors, it is supposed to be effective when the noise level is not high. Beyond the perturbation regime, one can consider the stochastic optimization algorithm to be proposed below.

III.2 Randomized b-GRAPE algorithm

To further deal with larger clock noises beyond the perturbation regime, we introduce our recently proposed b-GRAPE algorithm, a stochastic gradient-descent algorithm [24], for enhancing the control robustness against clock noises.

The basic idea is, instead of evaluating the average gate error with Eq. (LABEL:DeltaT), to directly average the error over a set of randomly chosen samples of clock noises $\mathcal{S}=\{\delta\mathbf{t}_{1},\delta\mathbf{t}_{2},\cdots,\delta\mathbf{t}_{K}\}$ according to some a priori probability distribution, as follows

[TABLE]

$J_{\mathcal{S}}$ is a good measure on the average error as long as the sample set $\mathcal{S}$ is sufficiently large, and it does not matter whether the noise is in perturbation regime or not. Robust and high precision control can be achieved if $J_{\mathcal{S}}$ can be made sufficiently small. However, such sampling-based algorithm [25] is computationally expensive when $K$ is very large, because the unitary evolution must be calculated for $N$ times corresponding to all samples in the set.

The b-GRAPE algorithm exploits the noise samples in a different way. It randomly picks a batch of samples for each iteration, say $\mathcal{S}^{(j)}=\{\textbf{t}_{1}^{(\ell)},\cdots,\textbf{t}_{B}^{(\ell)}\}$, and updates the control along the gradient evaluated with this batch, i.e.,

[TABLE]

where $\alpha_{\ell}$ is the learning rate. Since the batch size does not have to be large, the b-GRAPE algorithm can be efficiently carried out (e.g., using parallel computing), though the iteration process is noisy due to the randomly sampled batches. More importantly, b-GRAPE optimization using small batches can more easily find highly robust solutionsbecause the large artificial noises tend to steer the search away from poor non-robust solutions.

IV Simulation Results

In this section, we test the proposed robust control algorithms with an example of two-qubit control system, whose Hamiltonian is as follows:

[TABLE]

where $\sigma_{zk}$ ($k=1,2$) is the Pauli matrix of the $k$th qubit and the coupling strength is $g=2\pi\times 10$MHz. We aim to implementing a CNOT gate that is robust to clock noises. This system involves four independent control functions (including the real and imaginary parts of $u_{k}(t)=u_{kx}(t)+iu_{ky}(t)$, $k=1,2$). They are delivered to the qubits through two control channels (e.g., two separate control lines in a superconducting quantum computing system). Therefore, there are two mutually independent clock noises in this system.

In the simulation, the sampling period is chosen to be $T_{s}=1$ns and the pulse length be $T=50$ns (i.e., $M=50$ amplitude variables are to be optimized). The latencies $\tau_{1}$ and $\tau_{2}$ in the two channels are both uniformly sampled between [math]ns and $0.4$ns (i.e., $0-40\%$ of the sampling period). The covariance matrix can be calculated to be

[TABLE]

where each clock noise affects two controls in the corresponding channel. The jitter noises $\xi_{k}^{j}$ are uniformly sampled between $-0.05$ns and $0.05$ns (i.e., $\pm 5\%$ of the sampling period), whose variance is $\mu_{0}^{2}=8.33\times 10^{-4}{\rm ns}^{2}$. For comparison, we also perform the optimization with only latency noise (i.e., with the same $C^{\tau}$ but $\mu_{0}^{2}=0$). The simulation results of these two cases are shown in Fig. 2, in which both the homotopic and the b-GRAPE algorithms are applied.

In the homotopic algorithm, we first use a standard GRAPE algorithm to minimize the gate error $J_{0}$ down to machine precision based on the ideal control model (5). Then, we follow the projected gradient (16), in which the above calculated statistical parameters $\mu_{0}^{2}$ and $C^{\tau}$ are involved, to reduce the average gate error $J_{\rm N}$ while keeping $J_{0}$ to be sufficiently small. When $J_{0}$ rises up (above $10^{-6}$) due to the numerical error, we apply the GRAPE algorithm to correct it back to below $10^{-10}$. The actual robustness of each intermediate control field is evaluated by the average error tested over $10^{4}$ random samples. From the simulations, the statistic average gate error using testing samples agrees very well with $J_{\rm N}$ calculated by the estimation formula (12), showing that $J_{\rm N}$ can be used as a good approximation on the average gate error, and hence the robustness measure of control fields against clock noises.

As for the b-GRAPE algorithm, the batch size is chosen to be $B=5$ and the clock noises are sampled during the optimization according to the same probability distribution described above. The training curves are very noisy due to the chosen small batch size, but the testing curve (i.e., evaluating the average error for each intermediate control field with $10^{4}$ additional random noise samples) exhibits a steady decrease of the gate error.

The simulation results show that both algorithms can effectively enhance the control robustness against clock noises. The homotopic algorithm converges faster, but the ultimate average gate error it achieved is larger than that achieved by b-GRAPE algorithm. The difference is also shown in the analysis of gate error distribution in Fig. 3. In addition, both the distributions corresponding to the homotopic and GRAPE algorithms are skewed to the large-error side, while that corresponding to the b-GRAPE algorithm is almost normal. Therefore, the b-GRAPE algorithm tends to find more robust control fields.

Figure 4 shows how the gate error relies on the two latency noise parameters $\tau_{1}$ and $\tau_{2}$, where the jitter noise is absent. The fields obtained by b-GRAPE and homotopic algorithms can suppress the error below $10^{-3}$ over a large region, but GRAPE (without consideration of robustness) maintains high-precision only in a much smaller region. The homotopic algorithm is designed to always maintain highest control precision at $\tau_{1}=\tau_{2}=0$ns (corresponding to the noiseless ideal system). Interestingly, to achieve the overall high control precision, b-GRAPE algorithm adapts itself better to the noise distribution, as its highest precision at $\tau_{1}=0.24$ns and $\tau_{2}=0.06$ns is closer to the center of the sampling region. This explains why b-GRAPE algorithm can find more robust controls.

We also plot the optimized fields in Fig. 5. Taking the $y$-axis field $u_{2y}(t)$ on the second qubit as an example, we can see that the waveforms optimized with or without jitter noises are very different. The presence of jitter noise leads to much smoother fields because it penalizes the average error through the smoothness term $\|\delta{\bf u}\|^{2}$ derived in Eq. (12). By contrast (see Fig. 5b), the smoothness is almost unchanged when training the controls without jitter noises.

V Conclusion

To conclude, we have analyzed the robustness of quantum control against clock noises that are prevalent in multi-channel control signal generation devices. Two algorithms are introduced for improving the robustness by minimizing the average gate error induced by clock noises, and their effectiveness on robustness improvement is shown by simulation examples. In comparison, the homotopic algorithm converges faster but the b-GRAPE algorithm can achieve higher performance owing to its better adaptivity to the noise.

The proposed algorithms represent two frameworks, deterministic and stochastic, for optimizing robust control against clock noises. More advanced optimization techniques can be incorporated to further improve the control robustness and precision, e.g., Newton-Ralphson algorithms for faster convergence or momentum-based skills for stabilizing of training during b-GRAPE optimization.

Realistic quantum systems always involve multiple noises or uncertainties in addition to clock noises. Whether it is possible, and how to design controls when these noises coexist, is much more challenging. These problems are to be explored in future.