In situ upgrade of quantum simulators to universal computers

TL;DR

This paper introduces a method for transforming quantum simulators into universal quantum computers by using optimal control techniques that learn to implement logic gates directly on the simulator, bypassing classical modeling limitations.

Contribution

It proposes an in situ learning approach to efficiently construct quantum logic gates, enabling quantum simulators to be upgraded to universal quantum computers.

Findings

The scheme scales polynomially with the number of qubits.

Numerical simulations up to 9 qubits show promising results.

The method effectively bypasses classical modeling challenges.

Abstract

Quantum simulators, machines that can replicate the dynamics of quantum systems, are being built as useful devices and are seen as a stepping stone to universal quantum computers. A key difference between the two is that computers have the ability to perform the logic gates that make up algorithms. We propose a method for learning how to construct these gates efficiently by using the simulator to perform optimal control on itself. This bypasses two major problems of purely classical approaches to the control problem: the need to have an accurate model of the system, and a classical computer more powerful than the quantum one to carry out the required simulations. Strong evidence that the scheme scales polynomially in the number of qubits, for systems of up to 9 qubits with Ising interactions, is presented from numerical simulations carried out in different topologies. This suggests that this in situ approach is a practical way of upgrading quantum simulators to computers.

Figures

Equations

$$H=\sum _i\left(f_x^i(t){\sigma }_x^i+f_y^i(t){\sigma }_y^i\right)+\sum _{<i,j>}{H}^{i,j},$$

$$F(M,U)\ge F_{LE}(M,U)=1-\sum _i(1-F(M_i,U_i))$$

$$T_{\text{total}}=T_{\text{run}}{N}_{\text{runs}}/p_{\text{succ}}$$

$$N_{\text{runs}}=N_{\text{meas}}{N}_{\text{prec}}{N}_{\text{fids}}{N}_{\text{upds}}.$$

$$\text{Tr}[H\rho ]$$

$$\ge \sum _{k>0}⟨E_k⟩\rho E_k,$$

$$\text{Tr}[H\rho ]$$

$$\ge 1-⟨\psi ⟩\rho \psi .$$

$$\text{Tr}[H\rho ]$$

$$=\sum _i{\text{Tr}}_i[(\text{mathds}{1}_i-|{\psi }_i⟩⟨{\psi }_i|){\rho }_i]$$

$$=\sum _i(1-⟨{\psi }_i⟩{\rho }_i{\psi }_i),$$

$$M_i(\cdot )\equiv M(\cdot \underset{j\ne i}{⨂}\frac{1}{d_j}\text{mathds}{1}_j),$$

$$F(M,U)\ge 1-\sum _i(1-F(M_i,U_i)).$$

Full text

Recent and ongoing work on building large quantum systems is leading to simulators that are able to model physical phenomena, allowing questions about the underlying science to be answered [1, 2, 3]. These machines contain a register of quantum particles, typically two level quantum systems (qubits) storing quantum information. The presence of interactions between these leads to dynamics that, by varying control parameters in the system Hamiltonian, can replicate the quantum behaviour of systems of interest. This, however, is less general than a quantum computer which is able is to perform a universal set of logic gates on the qubits [4].

Provided some control parameters can be varied in time, it is in principle possible to do an arbitrary gate on a quantum many-body system such as a quantum simulator [5, 6, 7]. Finding the right time-dependency however relies almost exclusively on numerical methods, especially when physical constraints on the control fields are taken into account [8, 9]. These methods require a very precise knowledge of the parameters of a system, a daunting task for a machine with a huge number of degrees of freedom. Furthermore, they are intractable on a classical computer if the quantum simulator we want to solve the problem for is large enough to do something beyond the capabilities of classical computers. These two difficulties provide a major obstacle in using quantum simulators to perform arbitrary computation.

We circumvent these problems by showing how well-known existing numerical methods can be translated to run in situ on the quantum simulator itself, as illustrated in Fig.1. A mix of analytical and numerical results point towards this being a scalable, bootstrapping scheme for performing a universal quantum computation, needing resources that grow only polynomially with the number of qubits.

The core principle is to use the system at hand to implement and improve control pulses until they perform the desired gate on it. Such an adaptive approach to finding controls is naturally used in laboratory work and has been studied as a fine-tuning tool in small systems [10, 11], a way of controlling quantum chemistry with light [12], a method for stochastic optimisation [13], and a way of correcting parameter drift [14]. Using simulators as oracles for reaching quantum states has also been explored [15], as has the potential for a quantum speed up in general optimisation problems [16]. In this paper we propose a way to transform this general approach into a large scale, constructive method that provides a new avenue to control many-body quantum systems. Independently, and concurrently to the writing of this paper, a similar approach as ours was developed and tested experimentally for the different problem of quantum state preparation [17].

The scheme

The model we consider is a quantum simulator that has the underlying ability to be a universal quantum computer (one that can run an arbitrary algorithm), and the task is to learn how to use it as such. For this reason, we take the simulator as consisting of $n$ qubits with some interactions between them such that they form a fully connected graph where every qubit is (directly or indirectly) interacting with every other qubit. Furthermore we require that the timescale associated with this interaction is much shorter than the decoherence time in order for significant entanglement to be built up. In addition to this we need the ability to perform the following operations on each qubit individually: preparation in a complete basis set of states, fast rotations by applying strong Hamiltonians, and measurement in a complete basis set.

Such a system can be described by the Hamiltonian

[TABLE]

where the first sum is over all qubits and the time-dependent control functions $f(t)$ are to be determined. The second sum is over all connected qubits and $H^{i,j}$ is the interaction between qubit $i$ and $j$. The choice of $\sigma_{x}$ and $\sigma_{y}$ for the controls is for convenience, any two Hamiltonians will work, and does not have to be the same for all qubits. As the controls are found in situ, it is not necessary to know beforehand the form of the interactions $H^{i,j}$.

These requirements are significant, but much easier than demanding direct control over two qubit operations, and correspond to the state-of-the-art in systems involving trapped ions [18, 19, 20], cold atoms [21, 22], NMR [23, 24, 25] or superconducting circuits [26, 27]. In these systems there already exist quantum simulators powerful enough to do simulations, and satisfy our requirements, but are not currently usable as computers as it is not known how to perform logic gates on them [4, 2]. Our numerical results show that the scheme developed here scales well for a range of systems where $H^{i,j}$ is of the Ising type ($\sigma_{z}\otimes\sigma_{z}$). As Ising machines are useful for a wide range of quantum simulations and can be built with many different technologies [19, 22, 28], this is a result with wide ranging applicability.

In the model we consider, the connectedness of the qubits and the ability to do fast single qubit operations guarantees that the two core requirements of our proposed optimisation scheme are satisfied: there exists a universal gate set that can be reached at short times [6], and process tomography can be performed [29]. While other systems satisfy these requirements and the approach detailed here would work, we focus on this model for clarity. As single qubit operations are assumed, the gates that controls are needed for are entangling ones, canonically the controlled-not (C-NOT) gate; these are vastly harder to perform using conventional methods and typically have much lower fidelities.

The steps for finding such a gate in the in situ scheme are outlined in Fig.2. These are very general and almost the same as in classical numerical optimisation: a guess for the optimal values is generated, these are fed into a function that computes their effect, the distance between this and the desired outcome is calculated, and this generates another guess for the optimal values. This is iterated until the values get close enough to the goal, or the process terminates unsuccessfully after some timeout condition is reached. The difficulty with doing this for a quantum simulator of the type discussed above is in computing what unitary is produced by a given choice of control parameters; this requires both an accurate model of a high dimensional system and an exponentially large classical computer to solve it. Neither of those things can be done for a quantum system large enough to be an interesting quantum computer.

We eliminate these twin difficulties by using the quantum simulator to compute the effects of the control pulse on itself. This works because the simulator with a trial set of controls is guaranteed to be an accurate model of itself with those controls. The propagation step is therefore done in situ, but the method by which the control parameters are updated remains purely classical. This is because the information extracted from the quantum simulator (the gate fidelity) and the parametrisation of the control pulses are purely classical. An upshot of this is that the myriad of different methods to do numerical optimisation that have already been developed and work for quantum systems can be used in this protocol directly.

In order to use the quantum simulator as a universal computer, this optimisation procedure needs to be repeated for a universal set of gates. As single qubit operations are assumed, it is sufficient to find a complete set of C-NOT gates. The minimum number of these gates, such that every quantum circuit can be implemented, is $n-1$. In practice we expect it to be more efficient, and produce shorter circuits, to find the $\tfrac{1}{2}n(n-1)$ C-NOT gates that act between every pair of qubits. As is shown in the numerical section, this is readily achieved even for pairs of qubits that are not directly interacting.

The question of whether the scheme works when the system Hamiltonian varies in time uncontrollably is important for an experimental implementation. If this change in time happens slowly compared to the time it takes to find a control pulse for a given gate, then it does not impede the ability of the scheme to find that pulse. However, it may mean that the pulse no longer produces the required dynamics at a later point in time when it is being used as part of an algorithm. In this case, it would be required to eventually rerun the optimisation scheme in order to correct for this drift.

On the other hand, if the stochastic fluctuations in the Hamiltonian are faster than the evolution time required for a gate, the problem is a different one. Repeatedly evolving the system with the same controls (necessary in order to measure the fidelity) will result in the system evolving with a different Hamiltonian on each repeat. This noise in the Hamiltonian thus translates into a lower fidelity being measured. Therefore, as long as the fast fluctuations in the Hamiltonian are small, they are not expected to prevent the scheme from finding a successful pulse but will limit the maximum possible fidelity.

Local gate fidelity

The measure used to gauge how close the system evolution is to the desired unitary is typically the gate fidelity [31]. This is a function between the dynamical map $M$ which describes the evolution of the system under a set of controls (including potential decoherence which acts on the system), and the target unitary $U$. It is defined as $F(M,U)=\bra{\psi}\rho_{M}\ket{\psi}$ where $\ket{\psi}=U\otimes\mathds{1}\ket{\Omega}$ (with $\ket{\Omega}=\sum_{k}\ket{kk}$ being a maximally entangled state) is the Choi state of $U$; and $\rho_{M}=(M\otimes id)\ket{\Omega}\bra{\Omega}$ is the Choi state of $M$. This distance measure is bounded between [math] and $1$, with the upper limit being reached only when $M(\cdot)=U(\cdot)U^{\dagger}$. In the case of the system evolution being unitary simplifies down to $F(V,U)=|\tfrac{1}{d}\text{Tr}[V^{\dagger}U]|^{2}$. When the propagation step of Fig.2 is done classically, the whole unitary describing the evolution of the system is calculated as an exponentially large matrix from which the gate fidelity must be calculated.

In the in situ scheme this is no longer the case; the only thing which is accessible is a quantum state after it has been evolved by the quantum simulator under some control parameters. The standard method of extracting the gate fidelity is to perform a variant of process tomography, known as certification. This requires preparing the system in a specific state, evolving it, and then performing a set of measurements. The number of different preparation-measurement combinations, $N_{\text{meas}}$, is of order $O(d^{2})=O(2^{2n})$, and thus scales exponentially [32].

However it is possible to do exponentially better for cases of interest where the target gate has a tensor product structure, $U=\bigotimes U_{i}$ where each $U_{i}$ is a unitary which acts on a small number of qubits. This would typically be a single C-NOT on one pair of qubits and identity on the rest, $\text{C-NOT}_{1,2}\otimes\mathds{1}_{3}\otimes\mathds{1}_{4}\otimes...$, but it could be several simultaneous non-overlapping C-NOTs or even larger gates such as Tofolli. No matter what the exact form is, provided that the target can be decomposed into a tensor products of unitaries, the fidelity over the whole system is bounded by the local estimator $F_{LE}$ according to

[TABLE]

where $M_{i}(\rho_{i})=M(\rho_{i}\bigotimes_{j\neq i}\tfrac{1}{d_{j}}\mathds{1}_{j})$. This is the reduced dynamical map acting on subsystem $i$ where the other subsystems have been initialised in the maximally mixed state. This result is proved in the appendix below based on existing approaches [33].

The advantage of this local estimator to the fidelity is that it only requires certification to be performed over small dimensional subsystems of $1$ or $2$ qubits. As the size of these subsystems does not increase as the system is scaled up, the cost of measuring the fidelity does not increase exponentially with the number of qubits. Applying existing results for certification to each term in Eq.(2) sequentially gives $N_{\text{meas}}=O(\sum_{i}d_{i}^{2})=O(n)$. As is discussed in the methods section below, it is possible to remove this linear scaling by noting that each term in Eq.(2) can be recovered in parallel. This results in a constant cost, $N_{\text{meas}}=O(\max_{i}d_{i}^{2})=O(1)$, a vast improvement over the previous exponential scaling, $O(2^{2n})$.

Beyond being efficiently recoverable, this estimator to the fidelity is useful for a number of reasons. It is a lower bound on the gate fidelity, so we are guaranteed that the true fidelity is at least as good. It converges to the exact fidelity in the limit that $F(M,U)\to 1$, this is important as we are most interested in having a measure of how good a gate is when it is close to the target. As can be seen in Fig.3, it is well behaved numerically and the initial convergence is fast. Increasing the number of qubits would increase the number of terms in Eq.(2) but not their structure, therefore we expect the qualitative features to remain the same as it is scaled up. The minimum value of the local fidelity is $1-n$, while the true gate fidelity cannot go below [math], so it may be expected that the convergence to $1$ is slower in larger systems as the local fidelity has a larger range to cover.

The scaling behaviour of the local fidelity was investigated by considering a target $U_{T}=\text{C-NOT}\otimes\mathds{1}\otimes\mathds{1}...$ and comparing the gate fidelity and local fidelity between it and the unitary $U=e^{-iH}U_{T}$ , where $H$ is a random Hamiltonian generated by a Gaussian distribution and normalised to $||H||_{2}=0.1$. As the number of qubits was increased from $3$ to $14$, the true gate fidelity averaged over different random $H$ stayed the same ($~{}99.5\%$) while the local fidelity dropped linearly, by less than $0.2\%$ per qubit. This is in accordance with our intuition that the local fidelity behaves similarly for different numbers of qubits, with the principle difference being the linearly increasing number of terms in the sum of Eq.(2).

Numerical investigation

The local fidelity detailed in the previous section shows that it is possible to estimate the fidelity of a quantum gate efficiently as the size of the system increases, removing one direct barrier from the scalability of the in situ optimisation scheme. There are, however, other factors that determine the time the protocol takes which need to be taken into account to assess its scalability. This requires an expression for the total time required to construct a control sequence for a gate in terms of the number of qubits in the system. As this is an optimisation problem that would be done ‘numerically’ on a hybrid classical-quantum computer, analytic expressions could not be obtained. In order to investigate this we conducted simulations of the protocol on a purely classical computer. We explored systems from $3$ to $9$ qubits; memory constraints on the cluster we used made larger systems unfeasible due to the difficulty of evolving (and doing gradient based optimisation of) operators.

The average time needed to find a control sequence for a gate can be expressed as:

[TABLE]

where $T_{\text{run}}$ is the time it takes to do one run of a control sequence on the quantum simulator, $N_{\text{runs}}$ is the number of sequences that are run on the simulator until the protocol halts, and $p_{\text{succ}}$ is the probability that the protocol halts with a control pulse that reaches the desired fidelity. $T_{\text{run}}$ can be decomposed as $T_{\text{run}}=T_{\text{init}}+T_{\text{gate}}+T_{\text{meas}}$ which is the time to initialise the system, evolve the system under the interaction and control Hamiltonians, and then measure it respectively. $T_{\text{init}}$ and $T_{\text{meas}}$ are determined by the type of system being used; we take them as fixed and independent of the number of qubits. The gate time, on the other hand, is a free parameter that must be decided before starting the in situ optimisation.

The total number of runs can be similarly decomposed as

[TABLE]

$N_{\text{meas}}$ is the number of times the experiment with the same control pulse, but with different input states and measurement basis, must be repeated in order to measure the gate fidelity once. As the previous section showed, this is $O(1)$ for the local estimator to the fidelity, which is the measure used henceforth. $N_{\text{prec}}$ is the number of times the fidelity must be measured to acquire sufficient statistics such that the fidelity is known to the desired precision. $N_{\text{fids}}$ is the number of different fidelities that need to be measured for the optimisation algorithm to update the control sequence. It is $1$ for gradient-free methods, while for steepest-ascent methods it is $1$ plus the number of gradients (when they are measured by finite difference). $N_{\text{upds}}$ is the number of the times the control sequences must be updated, corresponding to the number of times the scheme goes around the loop of Fig.2.

The scaling relation of the terms in Eq.(3) depends on the underlying classical algorithm. We used a steepest ascent gradient method similar to Gradient Ascent Pulse Engineering (GRAPE) algorithm [34] which is commonly used for optimising quantum control on classical computers with great success. In this approach, each of the independent Hamiltonians that can be controlled are taken as piecewise-constant with $N_{\text{ts}}$ time-slots of equal widths that span the full gate time $T_{\text{gate}}$. We used analytical gradients in the simulations, for computational efficiency [8], which restricted us to piecewise constant and fixed $T_{\text{gate}}$.

The precision to which the fidelities need to be measured experimentally also needs to be specified. This could be done by either fixing $N_{\text{prec}}$ itself, or by repeatedly measuring the fidelity until the error of the mean is below a specified value. We approximated the latter approach numerically by rounding each local fidelity measurement to some numerical accuracy $A_{\text{num}}$ and calculated the equivalent $N_{\text{prec}}$. The in situ scheme therefore requires $T_{\text{gate}}$, $N_{\text{ts}}$ and $A_{\text{num}}$ to be chosen beforehand, as well as a target fidelity $F_{\text{targ}}$, and to know the number of different control Hamiltonians which, multiplied by $N_{\text{ts}}$, gives the total number of controls $N_{\text{ctrl}}$.

In order to simulate this completely numerically we also need to specify exactly what the control Hamiltonians and the constant interaction Hamiltonians are for a given system. This is not the case were this scheme done in situ experimentally. In an experiment $T_{\text{gate}}$ minimisation could be included in optimisation objectives as the gradients would be calculated via a finite-difference method. Alternative pulse parametrisation to piecewise constant could also be used, as best suits the experimental setup. All the different parameters mentioned above are summarised in Fig.4.

We conducted a number simulations of this approach with a Hamiltonian of the type described in Eq.(1) for different number of qubits and interaction topologies. They were completed using the quantum optimal control modules in QuTiP [35, 36, 37]. These provide methods for optimising a control pulse to some fidelity measure. The GRAPE implementation in QuTiP is described in the documentation, available at [37]. The code used to perform the numerical simulations is available in an open-source repository [38]. The local Choi fidelity measure customisation, and a method for automating locating the $p_{\text{succ}}$ threshold, were developed for this study; they are fully described in the code documentation. The optimal $T_{\text{gate}}$ and $N_{\text{ts}}$ were determined by trialling a range of alternatives. As the result of the optimisation depends on the initial random control amplitudes (uniformly distributed in $[1,1]$), each scenario was repeated multiple times to gain reliable statistics.

A high performance computing cluster was necessary for completing sufficient repetitions of the optimisation simulations of the larger systems in a reasonable time (the 9 qubit optimisations each required around four days of Intel Xeon CPU E5-2670 0 2.90GHz core processing time and were repeated hundreds of times). This is because the processing time required to optimise a pulse scales exponentially with system size due to the need to exponentiate the Hamiltonians in order to compute propagators. This difficulty precisely highlights the need to optimise pulses in situ for quantum systems of the size that would perform a useful quantum computation.

We found numerically that, for a range of examples, there exist values of $T_{\text{gate}}$ and $N_{\text{ts}}$ such that the in situ scheme converges. Fig.5 shows typical values of the most important parameters for a variety of topologies and interaction types. We consistently found that Ising systems were easier to find controls for than Heisenberg systems. In particular, our results suggest that in Heisenberg systems a GRAPE-based algorithm may require a $T_{\text{gate}}$ that scales exponentially with the number of qubits in order for the optimisation to succeed. We found that this discrepancy also existed in purely classical optimisation techniques.

This suggests that Heisenberg systems are intrinsically harder to solve with optimal control methods than Ising ones, and that this does not depend on whether an in situ or classical approach is used. This is consistent with Fig.3 where we compare the local estimator to the fidelity with the true fidelity for a $5$ qubit Heisenberg chain as a function of the iteration step as it is being optimised. The local estimator tracks the true fidelity steadily whether the underlying system is Heisenberg or Ising, the notable difference between the two plots is the plateau in the Heisenberg case. This shows that optimising the system is significantly harder and appears for both the local estimator and the true fidelity. An exponential scaling in the required gate time would make such an approach infeasible for a quantum computer.

Regardless of these numerical difficulties, it can be shown [6] that it is possible to do fast entangling gates on such Heisenberg systems by using fast local unitaries and Trotter compositions to decouple the system into simple disconnected components. The problem is therefore with the choice of the particular optimisation algorithm that struggles to find the solution. It may be the case that using a different algorithm inside our in situ protocol, such as parametrising the control Hamiltonians as a Fourier series rather than as piecewise-constant, would find control pulses for shorter gate times.

For the case of an Ising chain we also varied the number of qubits in order to hypothesise a likely scaling for $T_{\text{total}}$ in terms of the number of qubits in the system and found that a polynomial scaling matched very well. As the cost of doing a classical simulation of the in situ optimisation of the Ising chain is much lower than for the others, we also picked this system to investigate the impact of measurement noise by introducing a finite value of $A_{\text{num}}$, which parametrises the sensitivity of the system to measurement noise. The results are shown in Fig.6 and give us a good estimate of $N_{\text{upds}}=O(n)$ and $A_{\text{num}}=O(1/n)$. The latter implies that $N_{\text{prec}}=O(n^{2})$, due to the central limit theorem that states the number of repetitions required scales quadratically with the desired accuracy which gives $N_{\text{prec}}\propto A_{\text{num}}^{-2}=O(n^{2})$.

Putting this together with the previous results that $N_{\text{fids}}=O(n)$ for gradient based optimisation and $N_{\text{meas}}=O(1)$ for the local estimator fidelity gives $N_{\text{runs}}=O(n^{4})$. As this is done with a constant gate time and with a constant success probability, this implies that the time required to find a control sequence that implements a C-NOT gate on an Ising chain using a steepest-gradient in situ scheme scales as $T_{\text{total}}=O(n^{4})$.

The other system we investigated in depth was an Ising ring where the target C-NOT was between two next-nearest-neighbour or two randomly located qubits. Fig.7 shows the required $N_{\text{upds}}$ for up to $9$ qubits for this system. This graph is in agreement with the previous results of Fig.6 that the number of iterations required grows slowly with the number of qubits; in this case the results even show signs of being sub-linear. An unexpected feature shared by both sets of results is the low cost of the $3$ qubit case. Our intuition is that it is due to the additional symmetries present and the ease with which the single qubit not part of the target C-NOT gate can be kept disentangled.

The reason for picking the ring topology and not-nearest-neighbour target gate was to check whether the Ising chain results were unique, to demonstrate the applicability of the in situ approach to different systems, and to test its ability to reach more complex gates. Specifically, it shows that the scalability of the scheme did not rely on boundary effects or on qubits being adjacent to each other. While a quantum computer could be built using only nearest-neighbour gates, being able to entangle two arbitrary qubits in the time of a single gate drastically reduces the potential run time of algorithms.

Discussion

This polynomial scaling observed numerically in these two different cases is encouraging evidence that the protocol may indeed be efficient. Some of the components that make up this exponential scaling come from numerical data, so several fits are possible. However the points lie so close to a linear fit in Fig.6 that a different fit, such as an exponential one, would diverge only slowly. Fig.7 suggests than corrections to the fit are more likely to make it sub-linear than more costly. Although it is clear that the results presented here do not form an absolute proof of the scalability of an in situ control scheme for all quantum simulators, they are at the very least strong evidence that this is an powerful approach to take for moderately large systems of a few tens of qubits.

Systems of such a size are interesting as they correspond to the state-of-the-art that can be realised experimentally. Using the in situ scheme for such systems would likely find control sequences for entangling gates that are not currently known, and where purely classical numerical optimisation schemes would fail due to the enormous computational requirements. Furthermore, testing these predictions in such experiments would extend these results to numbers of qubits that are completely unattainable for a purely classical computer to model, and test this protocol closer to full-scale universal quantum computation.

One potential difficulty in optimal control is the existence of traps: local maxima of the fidelity that optimisation algorithms converge to which are not the global maxima. The question of whether traps exist in unitary control using the standard gate fidelity has been well studied [39, 40, 41], and the conclusion is that generic quantum control landscapes are almost always trap free. This may also apply to the local estimator of the fidelity; traps were not a problem for the numerical simulations we performed and found no evidence of any new traps in Fig.3 or elsewhere.

The numerical results presented here used GRAPE, which decomposed the control pulses into piece-wise constant functions. A potentially more powerful approach, and one which is harder to do classically but may be easier to implement physically, would be to decompose them by frequency [42], such as in CRAB [43, 44] and GOAT [45]. Such algorithms are slow to run classically due to the difficulty of exponentiating the time-dependent Hamiltonian, a step which is bypassed in the in situ scheme. They typically require fewer parameters to describe a successful control pulse and thus may prove faster than GRAPE when done experimentally. A different variation would be to change from a gradient based algorithm to a geometric or genetic one, or even to use machine-learning algorithms to learn about the system [46]. Ideas from robust control [47, 48] may also be usable in an in situ framework, in order to make the approach more resilient to fluctuations in the system Hamiltonian.

A future direction to take this work is to apply it to another important aspect of quantum computation: error correction. The protocol detailed here can be used in much the same way for this by replacing the target operation from a C-NOT gate, to one protecting some logical qubits. Preliminary results show that with a tuneable interaction the system can discover decoherence free subspaces and simple error correcting codes this way. Work remains on what the most useful tasks to optimise for are, and on showing the scalability of this approach.

Acknowledgements

This work was supported by EPSRC through the Quantum Controlled Dynamics Centre for Doctoral Training, the EPSRC Grant No. EP/M01634X/1, and the ERC Project ODYCQUENT. We are grateful to HPC Wales for giving access to the cluster that was used to perform the numerical simulations. Many thanks to Stephen Glaser and David Leiner for discussions on possible implementations.

Appendix

Local estimator to the fidelity

We derive a bound for the gate fidelity $F(M,U)=\braket{\psi}{\rho_{M}}{\psi}$ which is the fidelity of the Choi states of the target gate $U$ with the realised channel $M$ using methods derived from [33]. A more in depth analysis is available in [49]. The Choi state of $U$ is defined as $\ket{\psi}=U\otimes\mathds{1}\ket{\Omega}$, and the Choi state of $M$ is $\rho=(M\otimes id)\ket{\Omega}\bra{\Omega}$, where $id$ is the identity map, and $\ket{\Omega}=\sum_{k}\ket{kk}$ is a maximally entangled state between the original Hilbert space and a copy of it. We consider the case where the target operation $U$ is unitary and has a tensor product structure such that $U=\bigotimes_{i}U_{i}$. The Choi state of $U$ inherits its tensor product structure and is given by $\ket{\psi}=\bigotimes_{i}\ket{\psi_{i}}$.

To find a bound for $F(M,U)$ we begin by constructing the projectors $h_{i}=\mathds{1}_{i}-\ket{\psi_{i}}\bra{\psi_{i}}$ for each $U_{i}$. These projectors have a very simple spectrum with a single [math] eigenvalue with corresponding eigenket $\ket{\psi_{i}}$, and a degenerate orthogonal space with eigenvalue $1$. These projectors are summed together to form a Hamiltonian $H=\sum_{i}h_{i}\otimes\mathds{1}_{\bar{i}}$ such that each $h_{i}$ acts on its own part of the Hilbert space and is identity on the rest. This has a single $E_{0}=0$ eigenvalue with eigenstate $\ket{E_{0}}=\ket{\psi}$, while all its other eigenvalues are positive integers. By expanding this Hamiltonian in its eigenbasis $\{E_{k},\ket{E_{k}}\}$ we have

[TABLE]

as $E_{0}=0$ and all the other energies are one or greater. Next, using the identity $\text{Tr}[\rho]=\sum_{k\geq 0}\braket{E_{k}}{\rho}{E_{k}}=1$ we find

[TABLE]

From the definition of the gate fidelity this give $F(M,U)\geq 1-\text{Tr}[H\rho]$.

The expectation value of the Hamiltonian can be evaluated according to

[TABLE]

where $\rho_{i}=\text{Tr}_{\bar{i}}[\rho]$. This is also the Choi state of the map

[TABLE]

which is the map $M$ acting on subsystem $i$ with the other subsystems in the maximally mixed state. This results in Eq.(2)

[TABLE]

One way of measuring $F_{LE}$ is to prepare the state of one subspace in a basis state and all the others in a maximally mixed state, perform the simulation, measure the initial subspace, and then repeat for a tomographically complete basis set and for each subsystem; giving a cost of $N_{\text{meas}}=\sum_{i}O((d_{i})^{2})=O(n)$. However by noting that a maximally mixed state is a random mixture of pure states, the fidelity of each subsystem can be measured at the same time by preparing each one in a random pure basis state. In this case there is no scaling with the number of qubits as the number of repetitions required depends only on the size of the largest subsystem. This gives $N_{\text{meas}}=O(1)$.

While this shows that local fidelity is efficient to extract from an experimental set up, it is no easier than the gate fidelity to compute in numerical simulations. This is because it must be calculated from a unitary (or CPT map) which represents the evolution of the whole system of dimension $2^{n}$. Multiple partial traces of it are needed in order to compute the $M_{i}$ from Eq.(2), which is typically a slow operation. Indeed, the need to calculate the local fidelity was a considerable strain on our numerical simulations and one of the compounding reasons why we could not simulate larger systems.