Abstract
Accurate and efficient control of quantum systems is one of the central challenges for quantum information processing. Current stateoftheart experiments rarely go beyond 10 qubits and in most cases demonstrate only limited control. Here we demonstrate control of a 12qubit system, and show that the system can be employed as a quantum processor to optimize its own control sequence by using measurementbased feedback control (MQFC). The final product is a control sequence for a complex 12qubit task: preparation of a 12coherent state. The control sequence is about 10% more accurate than the one generated by the standard (classical) technique, showing that MQFC can correct for unknown imperfections. Apart from demonstrating a high level of control over a relatively large system, our results show that even at the 12qubit level, a quantum processor can be a useful lab instrument. As an extension of our work, we propose a method for combining the MQFC technique with a twirling protocol, to optimize the control sequence that produces a desired Clifford gate.
Introduction
Quantum computers promise to outperform their classical counterparts in many applications.^{1,2,3,4,5,6} A primary obstacle in building largescale quantum computers is the inadequacy of classical computers for the task of optimizing the experimental control field.^{7} Standard classical optimization algorithms are impractical in the long run since they have a running time that grows exponentially with the number of quantum bits (qubits).^{8} In theory, a complex quantum circuit can be decomposed into elementary gates that work on a restricted number of qubits (usually one or two) and should be readily implemented in experiment.^{9} In reality however, the control fields are never localized and the qubits interact and evolve even in the absence of the control fields. Consequently, the implementation of each elementary gate may require a control sequence that takes into account a subsystem involving many more than one or two qubits. Moreover, the number of elementary gates required for a quantum algorithm grows polynomially with the system size and the errors accumulate with each successive gate. Therefore, an effective and efficient way to optimize the control field and minimize errors is a key ingredient for scaling up quantum information processing devices.^{10}
Here we consider the task of optimizing a control field that will drive the quantum system from a fixed input state ρ _{ i } to a desired target state ρ _{ f }. This problem is important in quantum information processing, as numerous tasks, such as algorithmic cooling in ensemble quantum computing,^{11,12} magic state preparation in faulttolerant quantum computing^{13} and encoding in quantum key distribution,^{14} all rely on steering states regardless of the propagator. The gradient ascent pulse engineering (GRAPE) algorithm^{15} is the current stateoftheart algorithm to (classically) optimize the control field in quantum state engineering problems. It is widely used in NMR,^{16} electron spin resonance,^{17} nitrogenvacancy centers in diamond,^{18,19} superconducting circuits,^{20,21} and ion traps.^{22,23} The GRAPE method exploits the gradient of a fidelity function to update the control field iteratively.
GRAPE has two major drawbacks that are indeed common to all classical optimization algorithms: its running time is exponential in the size of the nqubit system, and its accuracy depends on the precision of experimentally obtained parameters describing the quantum system (e.g., the system Hamiltonian). Basically, it is a gradientbased iterative algorithm. At each iteration k, the algorithm computes the evolution of the system under the previous pulse, and produces a final state \(\tilde \rho\) and a fitness function \(f = {\rm{tr}}(\tilde \rho \rho _f)\). It then computes the current gradient g for the use of updating the pulse. Classically, the computation involves the matrix exponential and multiplication in the 2^{n}dimensional Hilbert space and hence takes an exponential (in the number of qubits n) amount of time. For instance, a cluster of 128 AMD Opteron 850 CPU (2.4 GHz) can only handle a problem size of about ten qubits using GRAPE.^{8}
Recently, Li et al.^{24} and later Rebentrost et al.^{25} showed that a quantum processor can be used to calculate f and g efficiently. A technique called measurementbased quantum feedback control (MQFC) enables direct measurement of f and g (see Fig. 1), allowing the quantum processor to optimize its own pulses. MQFC addresses both the issues of scalability and control inaccuracies due to imperfect system characterization.^{26,27} Moreover, this technique is transferrable to any implementation in which control fields steer the system evolution and measurement in a standard basis is possible. In this work, we implement MQFC on a 12qubit NMR quantum processor, and in particular demonstrate for the first time that MQFC enhances the control precision by about 10% due to its selffeedback property. Furthermore, by creating the 12coherent state we demonstrate the capability of our quantum processor to function as a universal 12qubit quantum processor with highfidelity individual controls. This is also one of the largest quantum processors with individualcontrol to date.
Results
In this paper, we refer to unnormalized deviation density matrices (without the identity term) as ‘states’, which is a standard convention in ensemble quantum computing. To distinguish from the Hamiltonian, we use capital X, Y, and Z to denote states and σ _{ x }, σ _{ y } and σ _{ z } to denote Hamiltonians, while they both refer to the same set of Pauli matrices.
Quantum processor
In our NMR quantum processor, the liquidstate sample is per^{13}C labeled (1S,4S,5S)7,7dichloro6oxo2thiabicyclo[3.2.0]heptane4carboxylic acid dissolved in d6acetone, which forms a 12qubit register. The 12 qubits are denoted by nuclear spins C_{1} to C_{7} (^{13}Clabeled) as qubits 1 to 7, and H_{1} to H_{5} as qubits 8 to 12 in the molecule shown by Fig. 2a. When placed in a static zmagnetic field, it has a system Hamiltonian
where \(\nu _0^i\) is the Larmor frequency of the ith qubit, J _{ ij } is the coupling between qubits i and j, and \(\sigma _z^i\) is the Pauliz operator of the ith qubit. The values of these parameters can be found in Appendix C (See Supplementary information).
The control Hamiltonian is due to the transverse control field applied in the x–y plane, which is often digitized into M slices with slice length Δt. In each slice, there are four constant control parameters, leading to a control Hamiltonian in the form of
where, for example, \({\rm{B}}_x^{\rm{C}}[m]\) means the xcomponent of the mth slice of control field in the ^{13}C channel.
The dynamics of the NMR system is governed by \({\cal H}_s\) and \({\cal H}_c\) simultaneously, with the propagator
where
The essence of NMR quantum information processing is to optimize a control field, i.e., find a sequence of B_{ x,y }[m], such that one can precisely realize a quantum gate or drive the system to a target state according to Eq. (3).
Fundamentals of the GRAPE algorithm
To implement a particular target gate or state we need to find an optimal B_{ x,y }[m]. One of the most prominent optimization algorithms to date is the GRAPE algorithm^{15} which was developed for the design of optimal control pulses in NMR spectroscopy. Here, we explain the basic principle of GRAPE by considering the problem of state engineering in the absence of relaxation.
Suppose the initial state of the spin system is ρ _{ i }, and the target output state is ρ _{ f }. After applying a Mslice trial control pulse, the system will evolve to
The fitness function defined as \(f = {\rm{tr}}(\rho _f\tilde \rho )\) serves as a metric for the control fidelity, with the form
Obviously, f is a function of 2M variables, and to find its optimum we calculate the gradient function to the first order
where \(\left[ {\sigma _{x,y}^k,U_1^m\left( {\rho _i} \right)} \right]\) is the commutator between \(\sigma _{x,y}^k\) and \(U_1^m\left( {\rho _i} \right)\). We may increase the fitness function f by using the gradient iteration rule
where ϵ is a suitably chosen step size.
The GRAPE algorithm proceeds as follows on a classical computer:

1.
start from an initial guess control B_{ x,y }[m];

2.
calculate \(\tilde \rho\) according to Eq. (5);

3.
evaluate fitness function \(f = {\rm{tr}}(\rho _f\tilde \rho )\);

4.
if f does not reach our preset value, evaluate gradient function g according to Eq. (7);

5.
update control variables according to Eq. (8), then go to step 2.
MQFC optimization
The GRAPE algorithm requires the calculation of \(U_1^M\), i.e., the dynamics of the system. This step is inefficient on a classical computer when the size of the system is large. In contrast, the scheme of MQFC optimization provides an alternative way which enables direct measurement of f and g in the experimental manner, or explicitly, via the quantum evolution and measurement of the quantum processor.
Without loss of generality, let us discuss the scenario of ensemble quantum computing. e.g., NMR quantum computing, where the state is usually written as a traceless deviation density matrix and a singleshot measurement is sufficient to get the expected value of an observable. For other systems that use the computational basis or projective measurement, the following procedure needs to be slightly modified and more repetitions may be required to get the estimate of f and g.
Measuring f is straightforward. For an nqubit system, the total number of elements in the Pauli basis is 4^{n}−1 (without the identity term). If the target state ρ _{ f } has some decomposition, say, \(\rho _f = \mathop {\sum}\nolimits_{\gamma = 1}^{\cal G} x_\gamma P_\gamma\) with respect to the Pauli basis, then the fitness function is
Here, \(1 \le {\cal G} \le 4^n\) denotes the number of nonzero components, P _{ γ } is the γth element of the Pauli basis, and x _{ γ } is its corresponding coefficient.
Therefore, \({\cal G}\) experiments are required to estimate f. In the γth experiment, we just need to apply the control field to the initial state ρ _{ i } and measure the expectation value 〈P _{ γ }〉 of \(\tilde \rho\). For a generic ρ _{ f } that contains all \({\cal G} = 4^n  1\) Pauli terms, measuring f in experiment is equivalent to carrying out full state tomography, and is thus inefficient. However, many tasks require the creation of a simple target state where \({\cal G}\) is quite small. For instance, if we aim to prepare the 12coherent state ρ _{ f } = Z^{⊗12}, one measurement is sufficient to obtain f.
Measuring g requires us to realize the commutator \([\sigma _{x,y}^k, \cdot ]\) inside Eq. (7). In fact,^{24}
in which \({\cal R}_{x,y}^k\) and \(\overline {\cal R} _{x,y}^k\) mean a π/2 rotation and −π/2 about x or y axis on the kth qubit, repsectively. By substituting Eq. (10) into Eq. (7), we get
The terms on the righthand side are very similar to the measurement of f in Eq. (6), and the only difference is the local ±π/2 pulse inserted between slices m and m + 1. Explicitly, the mth component of g _{ x,y } is a weighted sum of \(4n{\cal G}\) measurement quantities, where 4 comes from the ±π/2 pulses about the x and y axes, n from the sum over all the qubits, and \({\cal G}\) from the measurement of f. In each experiment, compared to the way of measuring f, we just need to insert a local π/2 pulse after the mth slice evolution. Provided that all the qubits are well individually addressed, high fidelities are attainable in implementing these local π/2 rotations.
In summary, we need \(4n{\cal G}M\) experiments in total to perform the gradient measurement, which is linear in the number of qubits.
Experimental MQFC optimization
Now we turn to the experiment where the MQFC optimization is used to create the 12coherent state in the 12qubit quantum processor. First, let us clarify that all other pulses except the MQFC pulse throughout our experiments are local rotations, which are generated from a subsystembased gradient ascent pulse engineering (SSGRAPE) approach.^{16} It is a technical improvement of the original GRAPE for our particular implementation, but does not address its poor scalability issue (see Appendix D, See Supplementary information). What makes the MQFC scheme remarkable is that, it does not involve the computationally expensive classical simulation of the 2^{12}dimensional quantum dynamics in the course of optimization.
For our optimization task, GRAPE is a powerful tool, but handling 12 qubits is near the limit of capability for a typical laptop computer. In contrast, MQFC is capable of overcoming this difficulty in certain cases. Taking our experiment as an example, MQFC is able to solve the problem of finding a control field that evolves singlecoherence ZI^{⊗11} into 12coherence Z^{⊗12} in a time that scales linearly with the number of qubits. The entire experimental procedure is depicted in Fig. 2c, with a stepbystep description in Appendix E (See Supplementary information).
First, we prepare 7coherence Z^{⊗7}I^{⊗5} on the seven ^{13}C spins, using the sequence in Fig. 2c before the MQFC optimization box. This procedure, benchmarked in our previous work,^{28} is mainly done with the aid of SSGRAPE. Subsequently, we create Z^{⊗12} via MQFC on the quantum processor, which is the main focus of this work. We attempt to optimize a control field, namely a shaped radio frequency (r.f.) pulse, to evolve the system from the input ρ _{ i } = Z^{⊗7}I^{⊗5} to the output ρ _{ f } = Z^{⊗12}. Our control field, as shown in the MQFC optimization box, is comprised of three subpulses to realize local rotations, and two free evolutions to let ^{13}C qubits interact with ^{1}H qubits for the purpose of generating higher coherence. The whole control field is digitized into M = 278 slices with Δt = 20 μs width, while 110 slices are for three subpulses and 168 slices remain zero to realize the two 1.68 ms free evolutions (Appendix E, See Supplementary information). The total dynamics of the pulse is given by \(U_1^M\) in Eq. (3).
The fitness function is defined as \(f = {\rm{tr}}(\rho _f\tilde \rho )\), a metric for the control fidelity, where \(\tilde \rho = U_1^M(\rho _i)\) is the experimental state and ρ _{ f } = Z^{⊗12} is the target. In our experiment, only one measurement of the expectation value of 〈Z^{⊗12}〉 suffices to attain f after each iteration. If f does not hit our preset value with the current control field, we navigate the control field along its gradient g. In fact, to measure g _{ x }[m] (the same for g _{ y }[m]) which is the gradient of slice m, we just need three steps: insert a local ±π/2 pulse on every qubit about xaxis between slice m and m + 1; apply this new control field to the initial state ρ _{ i } and measure f (see Fig. 2b); compute g _{ x }[m] by directly combining these ±π/2inserted results via Eq. (11). As long as accurate local ±π/2 pulses are available for each qubit, g can be measured on a quantum processor. In experiment, we have designed a 1 ms π/2 pulse on every ^{13}C nucleus with the simulated fidelity over 99.7% (Appendix D, See Supplementary information). Having the gradient, we can update the control field and continue the MQFC procedure until a desired f is attained.
Direct observation of 12coherence
After the preparation of the 12coherent state, the next step is to observe it. In NMR spectroscopy, multiple coherence is hard to be observed directly in a onedimensional spectrum, i.e., by flipping the target spin to the x–y plane while others remain in Z. If all coupling between the target spin and other spins can be resolved, such observation is feasible. For example, in a twoqubit system, we can flip spin one to X to observe ZZ. In fact, XZ can be written as
The first term X⊗0〉〈 0 leads to a positive peak at ν _{1}−J _{12}/2 in the spectrum, as the Jcoupling term shifts the frequency of qubit 1 by −J _{12}/2. Analogously, the second term X⊗1〉〈 1 leads to a negative (due to the minus sign before the term) peak at ν _{1} + J _{12}/2. Generally, these two peaks can be resolved in the spectrum as long as J is large enough to separate them in frequencies. However, to observe multiple coherence, this requirement is of great challenge, since all Jcouplings between the target spin and other spins should be sufficiently large to prevent the annihilations of positive and negative peaks. As a result, twodimensional spectra and special techniques are usually employed to observe multiple coherence in conventional NMR spectroscopy.
For the purpose of NMR quantum computing, it is certainly better if one can read out multiple coherence directly in a onedimensional spectrum, as onedimensional spectrum reflects the state information more intuitively and reduces experimental running time remarkably compared to the twodimensional spectroscopy. In our 12qubit processor, although there are a few couplings as small as 0.01 Hz (Appendix C, See Supplementary information), a direct observation of 12coherence Z^{⊗12} is still available on C_{7}. Figure 3a exhibits a strong agreement between experimental observation 12coherence with merely 32 scans and the simulation, after rescaling the experimental result by 1.21 times to compensate for decoherence. To the best of our knowledge, our experiment is the first direct observation of multiple coherence beyond ten spins, and provides a valid evidence that our 12qubit processor possesses excellent individual controllability and the potential to be a universal 12qubit quantum processor.
Readout sequence
Although the direct observation of 12coherence with 32 scans in Fig. 3a demonstrates our control precision, it is not suitable for the many experimental runs during the optimization since 32 scans leads to a great time cost. One solution is to decouple the five ^{1}H spins to boost the signaltonoise ratio (SNR) by 2^{5} = 32 times, which exactly compensates for the required scan number. We have designed a readout pulse sequence to realize it as shown in Fig. 4.
The local pulses in the readout sequence are computed by SSGRAPE, and the sequence is implemented before every measurement. The phase correction is a zrotation to neutralize the unwanted chemical shift rotation during the free evolution. If the state is Z^{⊗12}, the five ^{1}H spins will be evolved to the identity state after the readout sequence, and the decoupling of ^{1}H leads to the C_{7} spectrum as shown in Fig. 3b, which is measured with a single scan. We then use spectrum fitting to obtain the signal’s amplitude and phase, and thus the value of 〈Z^{⊗12}〉.
This readout sequence induces errors in terms of decoherence and pulse imperfections. For the former one, through our simulation we find that it leads to about 30% signal loss, which is reasonable since multicoherence is exceptionally vulnerable to decoherence. Therefore, this factor is taken into account for all the measurement results, that is, the measured values are rescaled by about 1.3. With respect to the pulse imperfection, it consists of two parts: the imperfection of the sequence itself, i.e., some approximations when we design this simple readout sequence, and the infidelities in implementing the pulses. In total, 3.5% error arises in simulation. We use this value as the uncertainty of the experimental value of 〈Z^{⊗12}〉, namely, the error bars in Fig. 3c.
Experimental results
Figure 3b shows the spectrum of \(\tilde \rho\) after the readout stage for each odd iteration. The peak intensities correspond to the value of \(f = {\rm{tr}}({\rm{Z}}^{ \otimes 12}\tilde \rho )\), which clearly shows that MQFC increases f during the optimization. This demonstrates that MQFC is a practical technique for designing control fields in large quantum systems.
Our experiment also exhibits MQFC’s ability of correcting unknown experimental errors. To demonstrate this improvement, we implement another group of 12coherencecreating experiments, where all experimental settings are the same except that the pulse is generated from the classical SSGRAPE method other than the MQFC approach. We then compare these two groups of experiments. Figure 3c illustrates the result of SSGRAPE and MQFC pulses both in simulation and experiment. Focusing on the final result at iteration 9 in Fig. 3d, in experiment SSGRAPE finally creates a 12coherence with f = 0.703 ± 0.034, whereas MQFC pulse creates f = 0.795 ± 0.027. This experimental improvement (nearly 10%) disagrees with simulation, as in simulation MQFC (0.830) is even worse than SSGRAPE (0.931).
Considering that MQFC is a feedbackcontrol process, some incomplete knowledge of the experimental quantum process, such as the nonlinearity of the pulse generator or imprecision of the molecular Hamiltonian, may be inherently corrected during the optimization. Indeed, the experiment clearly suggests that MQFC is advantageous in terms of correcting errors from unknown sources. Furthermore, we simulate the decoherence effect during the procedure, and find that the upper bound of \({\rm{tr}}({\rm{Z}}^{ \otimes 12}\tilde \rho )\) in the presence of dephasing noise is about 0.824 (see Methods). Note that our MQFC result finally reaches 0.795, which is very close to this bound, demonstrating that our control of this 12qubit processor is close to the theoretical prediction after accounting for decoherence.
Discussion
Scalability
One major concern about control methods is their scalability with the number of qubits n. Our MQFC protocol involves a single experiment to measure f and 4nM experiments to measure g for each iteration, where n is the number of qubits. Assuming each experiment takes τ _{exp} time, the MQFC in total consumes T _{ it } = (4nM + 1)τ _{exp} for each iteration. For comparison, one has to deal with massive 2^{n} × 2^{n} matrix multiplications and exponentials using GRAPE on a classical computer. The speedup comes from the fact that MQFC utilizes the evolution of the quantum system instead of computing the system’s dynamics when evaluating f and g.
For other potential problems when scaling up the GRAPE technique, MQFC confronts similar difficulties, such as how to effectively represent a generic target state, how to choose a good initial guess, how to determine the pulse parameters before optimization, and how many iterations are needed to reach a satisfactory fidelity. Unfortunately, experimental observation of running time vs. number of qubits is not likely in NMR, since changing the number of qubits would usually require a different sample with different characteristics. So we cannot experimentally compare the scaling of MQFC vs. GRAPE, instead we must be satisfied with the fact that MQFC performs well at the 12qubit level and should theoretically scale better than GRAPE under standard assumptions. See Appendix A (See Supplementary information) in for details.
One may also ask if there could be other classical algorithms that scale as well (or better than) MQFC. This question remains open, but it seems very unlikely—the gradient calculation is based on the dynamics as shown in Eq. (3), i.e., the expected classical algorithm needs to simulate the dynamics of an NMR system in an efficient way. Even when boiling down to our particular state engineering task, as far as we can tell, there is no employed numerical method^{29,30,31} to simplify such an optimization, despite extensive work on the subject since the early days of experimental quantum computing. Moreover, MQFC can correct unknown errors to some extent, while openloop algorithms should require knowledge about the noise spectrum in advance, which is usually impractical for large quantum systems. In this sense, another potential application of MQFC is to demonstrate the quantum computing supremacy,^{32} where initial endeavors have been made in other systems, for example in a recent fivephoton boson sampling experiment.^{33}
Optimizing clifford gates
While our experiment focuses on state engineering, MQFC can also be used for other quantum optimization tasks. As an example, we consider optimizing the pulse sequence for a generic Clifford gate. It is possible to use twirling to estimate the average gate fidelity of a Clifford gate efficiently.^{28} The twirling protocol is based on finding the fidelity between experimental states following the pulse sequence and the corresponding desired states following the ideal gate. In principle this should be done for a complete set of initial states, but a randomized protocol can be used to approximate the gate fidelity with a constant number of experiments. The MQFC protocol can be modified to extract the desired fidelities and optimize the pulse sequence accordingly (details in Appendix B, See Supplementary information). Note that right after our work, a fivequbit implementation of a different quantum algorithm for gate optimization was reported.^{34}
Comparison with previous work
MQFC was originally introduced in Ref. 24 where it was implemented on a 7qubit NMR processor. There are two significant improvements in our work. First, our work clearly demonstrates the superiority of MQFC in correcting unknown errors with around 10% fidelity boost compared to the best classical optimization result, while in the 7qubit experiment no improvement was observed. The reason could be that the characterization of a 7qubit system is much more accurate than a 12qubit one, indicating that MQFC should be more powerful when dealing with large systems as the knowledge of larger systems are more likely to be incomplete. Second, our 12qubit experiment lies at the cutting edge of present experimental quantum computing, and the capability of individual controls at this qubit number is stateoftheart. As a comparison, in a recent work,^{35} the 10qubit entanglement in a superconducting circuit is created with fidelity 0.668 using global control. Moreover, we demonstrated that at the 12qubit level, the algorithm is already fast enough to justify its use as a tool in the lab.
In summary, we have created a 12coherence state on an NMR quantum processor using MQFC. Our experimental procedure and result, in particular the direct observation of 12coherence with one qubit as the probe, signify the capability of our quantum processor to serve as a universal 12qubit quantum processor with highfidelity individual controls on each qubit. In terms of control field optimization, our experiment demonstrates two superiorities in efficiency and experimental performance of MQFC beyond its classical counterpart. MQFC requires a running time that scales linearly with the number of qubits, and yields about 10% improvement compared to the best result via classical optimization. This optimization approach could be exceptionally useful in a large system with incomplete characterization, and is readily transferrable to other systems such as superconducing circuits or nitrogenvacancy centers in diamond. We expect that, as experiments involving more than 10 qubits become more common, quantum feedback methods such as MQFC will become standard tools in quantum computing labs.
Methods
To numerically simulate the decoherence effect in our 12qubit system, we first make the following assumptions: the environment is Markovian; only the \(T_2^*\) dephasing mechanism is taken into account since T _{1} effect is negligible in our circuit; the dephasing noise is independent between all qubits; the dissipator and the total Hamiltonian commute in each pulse slice as Δt = 20 μs is small. With these assumptions, we solve the master equation in two steps for each Δt: evolve the system by the propagator in Eq. (3), and subsequently apply the dephasing noise for Δt which is an exponential decay of offdiagonal elements in the density matrix. The typical length of simulating our 12qubit experiment in the presence of dephasing noise is in the magnitude of days on a desktop computer. The simulation shows that at most F _{dec} = 0.824 of Z^{⊗12} can be achieved with the 5.56 ms MQFC pulse applied on Z^{⊗7}I^{⊗5}, which is reasonable as highorder coherence is very vulnerable to the dephasing noise. Alternatively speaking, the upper bound of the MQFC experimental result is 0.824, since the optimization procedure does not include the function of robustness against dephasing noise yet.
Data availability
The data sets generated and/or analyzed during the current study are available from the corresponding author on reasonable request.
References
 1.
Shor, P. W. Algorithms for quantum computation: discrete logarithms and factoring. In Proc. 35th Annual Symposium on Foundations of Computer Science 124–134 (IEEE Computer Society Press, Santa Fe, NM, USA, 1994).
 2.
Grover, L. K. A fast quantum mechanical algorithm for database search. In Proc. 28th Annual ACM Symposium on Theory of Computing 212–219 (ACM, New York, 1996).
 3.
Farhi, E. et al. A quantum adiabatic evolution algorithm applied to random instances of an npcomplete problem. Science. 292, 472–475 (2001).
 4.
Buluta, I. & Nori, F. Quantum simulators. Science. 326, 108–111 (2009).
 5.
Georgescu, I., Ashhab, S. & Nori, F. Quantum simulation. Rev. Mod. Phys. 86, 153 (2014).
 6.
Harrow, A. W., Hassidim, A. & Lloyd, S. Quantum algorithm for linear systems of equations. Phys. Rev. Lett. 103, 150502 (2009).
 7.
Ladd, T. D. et al. Quantum computers. Nature. 464, 45–53 (2010).
 8.
Gradl, T., Spörl, A., Huckle, T., Glaser, S. J. & SchulteHerbrüggen, T. Parallelising matrix operations on clusters for an optimal controlbased quantum compiler. In European Conference on Parallel Processing 751–762 (Springer, Berlin, Heidelberg, 2006). https://link.springer.com/chapter/10.1007/11823285_78.
 9.
Nielsen, M. A. & Chuang, I. L. Quantum computation and quantum information (Cambridge University Press, 2010). https://www.cambridge.org/core/books/quantumcomputationandquantuminformation/01E10196D0A682A6AEFFEA52D53BE9AE.
 10.
Brif, C., Chakrabarti, R. & Rabitz, H. Control of quantum phenomena: past, present and future. New J. Phys. 12, 075008 (2010).
 11.
Boykin, P. O., Mor, T., Roychowdhury, V., Vatan, F. & Vrijen, R. Algorithmic cooling and scalable nmr quantum computers. Proc. Natl. Acad. Sci. USA. 99, 3388–3393 (2002).
 12.
Baugh, J., Moussa, O., Ryan, C. A., Nayak, A. & Laflamme, R. Experimental implementation of heatbath algorithmic cooling using solidstate nuclear magnetic resonance. Nature. 438, 470–473 (2005).
 13.
Souza, A. M., Zhang, J., Ryan, C. A. & Laflamme, R. Experimental magic state distillation for faulttolerant quantum computing. Nat. Commun. 2, 169 (2011).
 14.
Bennett, C. H. Quantum cryptography: public key distribution and coin tossing. In International Conference on Computer System and Signal Processing 175–179 (IEEE, New York, 1984).
 15.
Khaneja, N., Reiss, T., Kehlet, C., SchulteHerbrüggen, T. & Glaser, S. J. Optimal control of coupled spin dynamics: design of nmr pulse sequences by gradient ascent algorithms. J. Magn. Reson. 172, 296–305 (2005).
 16.
Ryan, C., Negrevergne, C., Laforest, M., Knill, E. & Laflamme, R. Liquidstate nuclear magnetic resonance as a testbed for developing quantum control methods. Phys. Rev. A. 78, 012328 (2008).
 17.
Zhang, Y., Ryan, C. A., Laflamme, R. & Baugh, J. Coherent control of two nuclear spins using the anisotropic hyperfine interaction. Phys. Rev. Lett. 107, 170503 (2011).
 18.
Waldherr, G. et al. Quantum error correction in a solidstate hybrid spin register. Nature. 506, 204–207 (2014).
 19.
Dolde, F. et al. Highfidelity spin entanglement using optimal control. Nat. Commun. 5, 3371 (2014).
 20.
Motzoi, F., Gambetta, J., Rebentrost, P. & Wilhelm, F. K. Simple pulses for elimination of leakage in weakly nonlinear qubits. Phys. Rev. Lett. 103, 110501 (2009).
 21.
Egger, D. J. & Wilhelm, F. K. Optimized controlledz gates for two superconducting qubits coupled through a resonator. Supercond. Sci. Technol. 27, 014001 (2013).
 22.
Nebendahl, V., Häffner, H. & Roos, C. Optimal control of entangling operations for trappedion quantum computing. Phys. Rev. A. 79, 012312 (2009).
 23.
Schindler, P. et al. Experimental repetitive quantum error correction. Science. 332, 1059–1061 (2011).
 24.
Li, J., Yang, X., Peng, X. & Sun, C.P. Hybrid quantumclassical approach to quantum optimal control. Phys. Rev. Lett. 118, 150503 (2017).
 25.
Rebentrost, P., Schuld, M., Petruccione, F. & Lloyd, S. Quantum gradient descent and Newton’s method for constrained polynomial optimization. arXiv:1612.01789 (2016).
 26.
Vijay, R. et al. Stabilizing rabi oscillations in a superconducting qubit using quantum feedback. Nature. 490, 77–80 (2012).
 27.
Hirose, M. & Cappellaro, P. Coherent feedback control of a single qubit in diamond. Nature. 532, 77–80 (2016).
 28.
Lu, D. et al. Experimental estimation of average fidelity of a clifford gate on a 7qubit quantum processor. Phys. Rev. Lett. 114, 140505 (2015).
 29.
Daley, A. J. Quantum trajectories and open manybody quantum systems. Adv. Phys. 63, 77–149 (2014).
 30.
Mascarenhas, E., Flayac, H. & Savona, V. Matrixproductoperator approach to the nonequilibrium steady state of drivendissipative quantum arrays. Phys. Rev. A. 92, 022116 (2015).
 31.
Lloyd, S. & Montangero, S. Information theoretical analysis of quantum optimal control. Phys. Rev. Lett. 113, 010502 (2014).
 32.
Preskill, J. Quantum computing and the entanglement frontier. arXiv:1203.5813 (2012).
 33.
Wang, H. et al. Highefficiency multiphoton boson sampling. Nat. Photon. 11, 361–365 (2017).
 34.
Dive, B., Pitchford, A., Mintert, F. & Burgarth, D. In situ upgrade of quantum simulators to universal computers. arXiv:1701.01723 (2017).
 35.
Song, C. et al. 10qubit entanglement and parallel logic operations with a superconducting circuit. Phys. Rev. Lett. https://journals.aps.org/prl/accepted/da073Y7cPc31266793e1794762950ddacf05b460f (2017).
Acknowledgements
We thank Anthony P. Krismanich, Ahmad Ghavami, and Gary I. Dmitrienko for synthesising the NMR sample. This research was supported by CIFAR, NSERC and Industry of Canada. K.L., H.L., and G.L. acknowledge National Natural Science Foundation of China under Grant Nos. 11175094 and 91221205.
Author information
Affiliations
Contributions
D.L., J.L. and R.L. conceived the experiments. D.L. and K.L. performed the experiment and analyzed the data. D.L., H.K., A.P., G.F., and H.L. tested the sample and developed the control techniques. J.L. and A.B. provided theoretical support. G.L., J.B., B.Z., and R.L. supervised the project. D.L., K.L., and J.L. wrote the manuscript with feedback from all authors. D.L., K.L., and J.L. contributed equally to this work.
Corresponding authors
Ethics declarations
Competing interests
The authors declare that they have no competing financial interests.
Additional information
Publisher's note: Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Electronic supplementary material
Rights and permissions
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made. The images or other third party material in this article are included in the article’s Creative Commons license, unless indicated otherwise in a credit line to the material. If material is not included in the article’s Creative Commons license and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this license, visit http://creativecommons.org/licenses/by/4.0/.
About this article
Cite this article
Lu, D., Li, K., Li, J. et al. Enhancing quantum control by bootstrapping a quantum processor of 12 qubits. npj Quantum Inf 3, 45 (2017). https://doi.org/10.1038/s415340170045z
Received:
Revised:
Accepted:
Published:
Further reading

Enhancing Quantum Control by Improving ShapedPulse Generation
Physical Review Applied (2020)

Preparation of ordered states in ultracold gases using Bayesian optimization
New Journal of Physics (2020)

Experimental Realization of Shortcuts to Adiabaticity in a Nonintegrable Spin Chain by Local Counterdiabatic Driving
Physical Review Applied (2020)

Benchmarking quantum processors with a single qubit
Quantum Information Processing (2020)

Combining the synergistic control capabilities of modeling and experiments: Illustration of finding a minimumtime quantum objective
Physical Review A (2020)