# Modular quantum computation in a trapped ion system

## Abstract

Modern computation relies crucially on modular architectures, breaking a complex algorithm into self-contained subroutines. A client can then call upon a remote server to implement parts of the computation independently via an application programming interface (API). Present APIs relay only classical information. Here we implement a quantum API that enables a client to estimate the absolute value of the trace of a server-provided unitary operation $$U$$. We demonstrate that the algorithm functions correctly irrespective of what unitary $$U$$ the server implements or how the server specifically realizes $$U$$. Our experiment involves pioneering techniques to coherently swap qubits encoded within the motional states of a trapped $${}^{171}{{\rm{Yb}}}^{+}\,$$ ion, controlled on its hyperfine state. This constitutes the first demonstration of modular computation in the quantum regime, providing a step towards scalable, parallelization of quantum computation.

## Introduction

When Google upgrades their hardware, applications that make use of Google services continue to function without needing to update. This modular architecture allows a client, Alice, to leverage computations done by a third party, Bob, without knowing any details regarding how these computations were executed. Modularity is enabled by an interface—an established set of rules that specify how Alice delivers input to Bob, and how Bob returns relevant output to Alice. Once agreed, Alice can design technology that makes use of the Bob’s service as subroutines, while remaining blissfully ignorant of their implementation. Known as APIs (application programming interfaces), such interfaces are now industry standard. Their adoption is almost universal—from specifying how we leverage pre-built software packages as subroutines to how we interface remotely with present-day quantum computers.

Present interfaces assume only classical information is exchanged, limiting the scope of collaborative quantum computing. What happens when this information exchange is allowed to be quantum? Consider the scenario where Bob offers a service to implement some unitary operation $$U$$. A client, Alice wishes to evaluate the normalized trace $$T(U)={\rm{tr}}(U)/{2}^{n}$$ by calling on Bob’s service as a subroutine. If this can be achieved, the benefits are two-fold. Alice can treat Bob’s service as a black-box. She need not know anything about the quantum circuits that synthesize $$U$$. In addition, Alice can use the same device to evaluate the normalized trace of a different unitary $$U^{\prime}$$, by exchanging Bob’s service for another.

This is, in fact, impossible. To see this, note that $$T(U)$$ depends on the global phase of $$U$$—a quantity that is unphysical. Therefore, its determination would enable Alice to measure an unphysical quantity. Thus, the standard quantum algorithm for estimating $$T(U)$$, known as DQC11, cannot operate by offloading synthesis of $$U$$ to a third party (see Fig. 1a). Indeed, the design of devices that realize complex $$U$$-dependent processes, given some unknown $$U$$, has received considerable attention2,3,4,5,6,7,8,9,10. In this context, several no-go results have been established11,12,13,14,15, motivating recent works in identifying what sacrifices or restrictions are necessary to circumvent these no-go theorems14,15,16,17,18,19,20.

Here, we report on the experimental implementation of a workaround for the DQC1 algorithm. The key observation is that while $$T(U)$$ depends on the global phase, its modulus does not. The resulting protocol—modular DQC1—enables us to evaluate $$| T(U)|$$ by outsourcing implementation of $$U$$ to a third party15. We successfully use it to evaluate $$| T(U)|$$ for 19 different unitary operations. The quantum circuit for the client remains the same for each $$U$$—guaranteeing true modular architecture. The physical implementation involves a new implementation of the controlled swap (CSWAP) gate—coherently swap two motional modes of an ion trapped in a three-dimensional harmonic oscillator, controlled on the internal levels of the trapped ion. Our experimental techniques are scalable, resilient to noise on part of the client, and chaining multiple iterations enables a modular variant of Shor’s factoring algorithm that requires fewer entangling gates21. This presents the first demonstration of a modular quantum algorithm and provides an important step towards collaborative quantum computing.

## Results

### Framework

The modular DQC1 algorithm can be understood by dividing its actions into two separate parties, which we refer to here as server and client. The server, Bob, offers the service of implementing an $$n$$-qubit unitary process. Interaction with a client, Alice, is enabled by a publicly announced quantum interface. The interface specifies a designated Hilbert space of a designated quantum system $$S$$ in which client and server are to exchange quantum information. For simplicity, we assume that the agreed system and Hilbert space used by client to send input quantum states to the server in the same as that used by the server to deliver output quantum states to the client. In principle, this need not be the case (see methods for formal definition). Bob is not constrained to preserve information stored in any other degrees of freedom within $$S$$. This is an important point. If Alice is guaranteed that Bob will preserve certain additional degrees of freedom, she is able to synthesizes certain $$U$$-dependent process that would otherwise be impossible14,15. Our goal is to take on the role of Alice, and build a device that employs Bob’s service as a subroutine to evaluate $$| T(U)|$$.

To do this, Alice begins with a bipartite system, consisting of $$S$$ to be delivered to Bob and some $$A$$ that she retains for the duration of the protocol. The protocol then contains two distinct tasks (see Fig. 1b):

Preprocessing—representing Alice’s necessary actions of preparing some $${\rho }_{1}$$ on the joint system $$A\otimes S$$ before delivery of $$S$$ to Bob;

Postprocessing—representing Alice’s actions to retrieve $$| T(U)|$$ from the state $${\rho }_{2}=U{\rho }_{1}{U}^{\dagger }$$ after receiving Bob’s output. Here, $$U$$ represents the unitary process on $$S$$ implemented by Bob.

Alice can achieve this by taking a single pure qubit initialized in state $$| +\rangle =(| 0\rangle +| 1\rangle )/\sqrt{2}$$, together with two maximally mixed $$n$$-qubit registers. In the preprocessing stage, she coherently swaps the two registers, controlled on the pure qubit to obtain $${\rho }_{1}$$. Alice then forwards one of the registers to Bob via the specified interface and awaits the result of Bob’s computation. Upon receipt of this result, Alice enters the postprocessing stage. This involves a second application of the control swap gate. Measurement of the ancilla in the $${\sigma }_{1}=\left|0\right\rangle \left\langle 1\right|+\left|1\right\rangle \left\langle 0\right|$$ basis then has expectation value of $$| T(U){| }^{2}$$, enabling efficient estimation of $$| T(U)|$$. Further details are shown in Fig. 1b.

The combination of preprocessing and postprocessing constitutes the modular DQC1 protocol. Critically, neither procedure depends on the physical means that Bob chooses to realize $$U$$. For instance, Bob could initially implement $$U$$ by applying physical operations directly on the system $$S$$. Alternatively, Bob could map the received quantum state to a more efficient physical platform for information processing, and implement $$U$$ on that platform. Alice’s modular DQC1 protocol would function regardless. Moreover, Alice’s preprocessing and postprocessing procedures are independent of matrix elements of $$U$$. This becomes pertinent in cases where $$U$$ could represent some unknown environmental process. The protocol then functions as a probe, able to efficiently estimate $$| T(U){| }^{2}$$ for any such process without the need for full tomography.

### Implementation

We demonstrate a proof of principle realization of modular DQC1 using a trapped $${}^{171}{{\rm{Yb}}}^{+}\,$$ ion in a harmonic potential when $$n=1$$. In this special case, the protocol involves a system of three qubits. Qubit $${\rm{C}}$$ represents the control, which is encoded into the internal states of $${}^{171}{{\rm{Yb}}}^{+}\,$$. Two registers, denoted as qubits $${\rm{X}}$$ and $${\rm{Y}}$$, are encoded into the external motional levels of $${}^{171}{{\rm{Yb}}}^{+}\,$$. Unitary operations on qubit $${\rm{C}}$$ are performed by applying resonant microwaves22,23. Meanwhile entangling gates between the ancilla and the two registers are realized by applying counter-propagating Raman laser beams with appropriate frequency differences and phases24,25,26,27,28.

The theoretical circuit for modular DQC1 has also been further tailored for the ion trap system. Notably, during both preprocessing and postprocessing, Alice has inserted an extra SWAP gate between qubit $${\rm{C}}$$ and qubit $${\rm{X}}$$. The actions of these SWAP gates have no effect on the algorithms output, but benefit this particular set-up, as the control qubit in the ion trap system is most directly accessible—and thus the most practical one for outsourcing operations to a third party. For the proof-of-principle experiment, we simulate the scenario where Bob operates on $${\rm{C}}$$ directly—with understanding that in more realistic scenarios, information within $${\rm{X}}$$ is likely first mapped to some flying qubit to be delivered to Bob. Fig. 2 illustrates further details.

During preprocessing, the standard circuit design for synthesizing $${\rho }_{1}$$ involves application of a CSWAP gate on registers $${\rm{X}}$$ and $${\rm{Y}}$$ with qubit $${\rm{C}}$$ as the control. Since $${\rho }_{1}$$ is input-independent, any means of preparing this state is equally valid. Here, we perform preprocessing without explicitly using the CSWAP gate, with no impact on practical usages and scalability (see Supplementary Notes 1 and 2). Subsequently, a second SWAP is then used to interchange information between $${\rm{X}}$$ and $${\rm{C}}$$—enabling $${\rm{C}}$$ to be used as the interface qubit.

During postprocessing, a second CSWAP gate is necessary for extracting information about $$| T(U)|$$ from $${\rho }_{2}$$. This $${\rho }_{2}$$ is input-dependent, thus the CSWAP gate needs to be synthesized online. In our experiment, we pioneer a technique to achieve this involving motional qubits and a sequence of Raman laser beams together with microwaves (see Fig. 3. The full implementation of CSWAP is illustrated in Supplementary Note 1). Appropriately configured measurements on qubit $${\rm{C}}$$ via fluorescence detection will then have measurement outcomes with an expectation value of $$| T(U){| }^{2}$$. Repeated applications of the protocol thus efficiently estimate $$| T(U)|$$ to any specified accuracy.

To characterize the faithfulness of our CSWAP operation, we find its $$8\times 8$$ truth table. The implementation achieves a fidelity (classical gate fidelity29) of $$0.85\pm 0.02$$ (see Supplementary Note 3 for details). In methods, we illustrate that effects of these imperfections can be mitigated—such that use of our CSWAP operations does not impact Alice’s capability to efficiently estimate $$| T(U)|$$ to any fixed error.

### Experimental benchmarks

To benchmark Alice’s protocol, our experiment also needs to simulate the actions of the server Bob. Critically, we ensure that our experimental procedure for enacting Alice’s modular DQC1 protocol in both preprocessing and postprocessing remains invariant regardless of which $$U$$ is implemented. Operationally, this enables us to simulate the following scenario:

1. 1.

Alice performs relevant preprocessing and walks away from her lab.

2. 2.

Bob then implements $$U$$ on $${\rm{C}}$$ in her absence.

3. 3.

Alice can then return to perform estimation of $$| T(U)|$$ without specific knowledge, which $$U$$ was implemented, or what methodology Bob used.

This enables us to illustrate the core tenet of modularity—that the client’s circuit does not need to change depending on $$U$$.

During benchmarking, we assess Alice’s performance for a wide range of unitaries $$U$$. Specifically, these include unitaries of the form $${U}_{\sigma }(\chi )=\exp (-i\chi \sigma /2)$$, where $$\sigma \in \{{\sigma }_{1},{\sigma }_{2},{\sigma }_{3}\}$$ involves all three possible Pauli operators, and $$\chi \in \{0,\pi /6,\pi /3,\pi /2,2\pi /3,5\pi /6,\pi \}$$ as shown in Fig. 4. For each choice of $$U$$, the protocol was executed 1000 times to obtain an estimation of $$| T(U){| }^{2}$$—denoted as $$M(U)$$—with standard error of ~0.02.

We compare these experimental results to their theoretical predictions in Fig. 4a. As we can see, the experimental estimations of $$| T(U){| }^{2}$$ are significantly lower than their true values. Fortunately, Alice is able to calibrate her device to account for these errors. To do this, she assumes the resulting estimations $$M$$ are offset by a scaling factor of $$\lambda$$, i.e., $$M(U)=\lambda | T(U){| }^{2}$$. Alice can determine $$\lambda$$ by first benchmarking her device against an ‘identity server’ (e.g., preforming preprocessing and postprocessing without calling on the services of Bob). The effectively evaluates $$M(I)$$—which should output 1 under ideal conditions, and thus enables immediate estimation of $$\lambda$$. She can then scale all results by a factor of $$1/\lambda$$. As this scaling is independent of how the server implements $$U$$, this form of error correction does not impact modularity of the procedure.

In our experiment, the value $$\lambda$$ is determined to be $$0.69\pm 0.02$$ to a confidence level of 95%. The re-calibrated estimations for $$| T(U){| }^{2}$$ are plotted with theoretical predictions in Fig. 4b. As we can see, Alice’s estimations of $$| T(U){| }^{2}$$ are now in good agreement with their true values. As such, we illustrates that modular DQC1 can continue to operate in today’s experimental conditions.

## Discussion

Here, we experimentally demonstrated the first modular quantum protocol—a variation of the standard DQC1 protocol that allows a device to determine the normalized trace of a completely unknown unitary process $$U$$. The experiment illustrates how Alice can outsource part of the computation to Bob—namely the realization of $$U$$. Alice needs no knowledge of how Bob chooses to realize $$U$$. The only information Alice and Bob need to share is an agreement on how to communicate quantum information to each other. Modular architecture has been critical in distributed classical computing. Our experiment presents its analog in the quantum regime.

Our implementation involved the design and realization a coherent quantum controlled swap gate, swapping two motional modes of a trapped ion depending on its internal hyperfine states. This technique presents a more favorable means of scaling than encoding qubits only within the internal states of ions. In Supplementary Note 1, we illustrate that our techniques can be adapted to efficiently swap two registers containing many motional modes, controlled on the hyperfine states of single ion. Meanwhile employing higher-energy excitations of the motional modes can enable potential coherent swaps of continuous variable degrees of freedom. These techniques provide possible means of realizing a number of interesting quantum protocols, including quantum anomaly detection30, and quantum computing with continuous variable encodings31.

## Methods

### Formal framework

A quantum application programming interface (API) specifies a public agreement between a client and server in how to communicate quantum information15. In particular, an interface $$\mathcal{I}$$ involves two tuples:

1. 1.

$${\mathcal{I}}_{\mathrm{in}}=(S_{\mathrm{in}},{\mathcal{H}}_{\mathrm{in}},{\mathcal{B}}_{\mathrm{in}})$$ consisting of the physical system $$S_{\rm{in}}$$, and precise Hilbert space $${\mathcal{H}}_{\rm{in}}$$ that Alice promises to use to deliver information to the server, as well as the computational basis $${\mathcal{B}}_{\rm{in}}$$, which Alice will use to encode this information.

2. 2.

$${\mathcal{I}}_{{\rm{out}}}=({S}_{{\rm{out}}},{\mathcal{H}}_{{\rm{out}}},{\mathcal{B}}_{{\rm{out}}})$$ consisting of the exact physical system $${S}_{{\rm{out}}}$$, Hilbert space $${\mathcal{H}}_{{\rm{out}}}$$, and computational basis $${\mathcal{B}}_{{\rm{out}}}$$, which the server will use to return output quantum information to Alice.

We then say that a server, Bob, implements $$U$$ via interface $${\mathcal{I}}$$ if on delivery of $$| \phi \rangle$$ encoded within $${\mathcal{I}}_{{\rm{in}}}$$, Bob will return $$U| \phi \rangle$$ encoded within $${\mathcal{I}}_{{\rm{out}}}$$. Note that in many settings, our experiment included, $${\mathcal{I}}_{{\rm{in}}}={\mathcal{I}}_{{\rm{out}}}$$.

Once an interface is agreed. Alice can then design modular algorithms that take advantage of Bob’s service. Formally, we define two possible classes of elementary actions

1. 1.

Implement some elementary circuit elements (e.g., a elementary quantum gate, a single-qubit measurement)

2. 2.

Call upon the server to act on $${S}_{{\rm{in}}}$$ and wait for reception of $${S}_{{\rm{out}}}$$

A modular quantum algorithm is then defined as a $$U$$-independent sequence of elementary actions that enable Alice to realize a quantum process $${\mathcal{P}}[U]$$ whenever Bob implements $$U$$. In our experiment, $${\mathcal{P}}[U]$$ was a quantum process whose output allowed efficient estimation of $${\rm{tr}}(U)$$. The key advantages of this modular architecture is that it ensures

• Independence of realization—Alice’s algorithm realizes $${\mathcal{P}}[U]$$, irrespective of what sequence of physical operations Bob uses to implement $$U$$.

• Independence of function—If Alice wishes to realizes $${\mathcal{P}}[V]$$, she does not need to modify her algorithm. She just needs to find a server that implements $$V$$ instead of $$U$$ via interface $${\mathcal{I}}$$.

We note also that while in many practical scenarios, client and server would be spatially separated, this need not be the case. An examples of local APIs in the classical setting are software packages, where certain functions can be invoked as subroutines without needing to know their details.

### Client error calibration

Here, we illustrate details of how Alice can calibrate her device to account for experimental noise in her set-up. Specifically, the expected output state of the circuit immediately prior to the measurement is

$${\rho }_{{\rm{ideal}}}=\frac{1}{{2}^{2n+1}}\left(\begin{array}{cc}{I}^{\otimes 2n}&U\otimes {U}^{\dagger }\\ {U}^{\dagger }\otimes U&{I}^{\otimes 2n}\end{array}\right).$$
(1)

Measurement in Pauli-X basis then yields the desired expectation value of $${\langle {\sigma }_{1}\rangle }_{{\rm{ideal}}}=| T(U){| }^{2}$$. By the central limit theorem, she can thus estimate $$| T(U){| }^{2}$$ to any specified accuracy $$\epsilon$$ by repeating the procedure $$O(1/{\epsilon }^{2})$$ times.

In our actual experiment, Alice’s device is not ideal. The dominant noise occurs during the implementation of CSWAP gate, caused by fluctuations in the magnetic field, trap frequencies, polarization, and intensity of the Raman lasers. This introduces decoherence, such that Alice obtains

$${\rho }_{\exp }=\lambda {\rho }_{{\rm{ideal}}}+(1-\lambda )\frac{I}{{2}^{2n+1}}$$
(2)

in place of $${\rho }_{{\rm{ideal}}}$$, where $$0\le 1-\lambda \le 1$$ benchmarks the level of effective decoherence. Subsequent Pauli-X yields expectation values $${\langle {\sigma }_{1}\rangle }_{\exp }=\lambda | T(U){| }^{2}$$. Alice can estimate the value of $$\lambda$$ by effectively running modular DQC1 using $$U=I$$, without making use of a third party service. Once $$\lambda$$ is determined, Alice can mitigate the effects of noise by setting her estimation to be $$| T(U){| }_{{\rm{est}}}^{2}={\langle {\sigma }_{1}\rangle }_{\exp }/\lambda$$, enabling an estimation of accuracy $$\epsilon$$ with $$O({\lambda }^{-2}{\epsilon }^{-2})$$ server calls. Therefore, our modular DQC1 algorithm is resilient to experimentally dominant sources of noise on the part of client.

We note that in this entire procedure, Alice’s actions does not depend on which unitary Bob implements, or how he chooses to implement this unitary. Thus, the noise-corrections do not affect the modular nature of the algorithm.

## Data availability

The data that support the findings of this study are available from the corresponding author upon reasonable request.

## References

1. 1.

Knill, E. & Laflamme, R. Power of one bit of quantum information. Phys. Rev. Lett. 81, 5672–5675 (Dec 1998).

2. 2.

Chiribella, G., D’Ariano, G. M. & Perinotti, P. Theoretical framework for quantum networks. Phys. Rev. A 80, 022339 (2009).

3. 3.

Chiribella, G., D’Ariano, G. M. & Perinotti, P. Quantum circuit architecture. Phys. Rev. Lett. 101, 060401 (2008).

4. 4.

Chiribella, G., D’Ariano, G. M. & Perinotti, P. Transforming quantum operations: quantum supermaps. EPL (Europhys. Lett.) 83, 30004 (2008).

5. 5.

Pollock, F. A., Rodríguez-Rosario, C., Frauenheim, T., Paternostro, M. & Modi, K. Non-markovian quantum processes: complete framework and efficient characterization. Phys. Rev. A 97, 012127 (2018).

6. 6.

Kretschmann, D. & Werner, R. F. Quantum channels with memory. Phys. Rev. A 72, 062323 (2005).

7. 7.

Aharonov, Y., Popescu, S., Tollaksen, J. & Vaidman, L. Multiple-time states and multiple-time measurements in quantum mechanics. Phys. Rev. A 79, 052110 (2009).

8. 8.

Hardy, L. The operator tensor formulation of quantum theory. Phil. Trans. R. Soc. A: Math. Phys. Eng. Sci. 370, 3385–3417 (2012).

9. 9.

Costa, F. & Shrapnel, S. Quantum causal modelling. New J. Phys. 18, 063032 (2016).

10. 10.

Allen, J. A., Barrett, J., Horsman, D. C., Lee, C. M. & Spekkens, R. W. Quantum common causes and quantum causal models. Phys. Rev. X 7, 031021 (2017).

11. 11.

Araújo, M., Feix, A., Costa, F. & Brukner, C. Quantum circuits cannot control unknown operations. New J. Phys. 16, 093026 (2014).

12. 12.

Chiribella, G., D’Ariano, G. M., Perinotti, P. & Valiron, B. Quantum computations without definite causal structure. Phys. Rev. A 88, 022318 (2013).

13. 13.

Miyazaki, J., Soeda, A. & Murao, M. Universal complex conjugation of quantum states and unitaries: implementation algorithm and implications. arXiv e-prints, page arXiv: http://arXiv.org/abs/1706.03481 June (2017).

14. 14.

Friis, N., Dunjko, V., Dür, W. & Briegel, H. J. Implementing quantum control for unknown subroutines. Phys. Rev. A 89, 030303 (2014).

15. 15.

Thompson, J., Modi, K., Vedral, V. & Gu, M. Quantum plug n’ play: modular computation in the quantum regime. New J. Phys. 20, 013004 (2018).

16. 16.

Lloyd, S., Mohseni, M. & Rebentrost, P. Quantum principal component analysis. Nat. Phys. 10, 631 (2014).

17. 17.

Sheridan, L., Maslov, D. & Mosca, M. Approximating fractional time quantum evolution. J. Phys. A: Mathematical Theoretical 42, 185302 (2009).

18. 18.

Nakayama, S., Soeda, A. & Murao, M. Quantum algorithm for universal implementation of the projective measurement of energy. Phys. Rev. Lett. 114, 190501 (2015).

19. 19.

Friis, N. et al. Flexible resources for quantum metrology. New J. Phys. 19, 063044 (2017).

20. 20.

Zhou, X.-Q. et al. Adding control to arbitrary unknown quantum operations. Nat. Commun. 2, 413 (2011).

21. 21.

Shor, P. Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer. SIAM Rev. 41, 303–332 (1999).

22. 22.

Zhang, X. et al. Time reversal and charge conjugation in an embedding quantum simulator. Nat. Commun. 6, 7917 (2015).

23. 23.

Shen, Y. et al. Quantum implementation of the unitary coupled cluster for simulating molecular electronic structure. Phys. Rev. A 95, 020501 (2017).

24. 24.

Leibfried, D., Blatt, R., Monroe, C. & Wineland, D. Quantum dynamics of single trapped ions. Rev. Mod. Phys. 75, 281–324 (2003).

25. 25.

Gulde, S. et al. Implementation of the deutsch-jozsa algorithm on an ion-trap quantum computer. Nature 421, 48 (2003).

26. 26.

Hsiang-Yu, L. et al. Spin-motion entanglement and state diagnosis with squeezed oscillator wavepackets. Nature 521, 336–339 (2015).

27. 27.

Ding, S., Maslennikov, G., Hablützel, R. & Matsukevich, D. Cross-kerr nonlinearity for phonon counting. Phys. Rev. Lett. 119, 193602 (2017).

28. 28.

Zhang, K. et al. Operational effects of the unot gate on classical and quantum correlations. Sci. Bull. 63, 765–770 (2018).

29. 29.

Patel, R. B., Ho, J., Ferreyrol, F., Ralph, T. C. & Pryde, G. J. A quantum fredkin gate. Sci. Adv. 2, e1501531 (2016).

30. 30.

Liu, N. & Rebentrost, P. Quantum machine learning for quantum anomaly detection. Phys. Rev. A 97, 042315 (2018).

31. 31.

Lau, H.-K. & Plenio, M. B. Universal quantum computing with arbitrary continuous-variable encoding. Phys. Rev. Lett. 117, 100501 (2016).

## Acknowledgements

This work was supported by the National Key Research and Development Program of China under Grants No. 2016YFA0301900, No. 2016YFA0301901, and the National Natural Science Foundation of China Grants No. 11574002, the National Research Foundation of Singapore (Fellowship NRF-NRFF2016-02), the John Templeton Foundation (grant 54914), and the National Research Foundation and the Agence Nationale de la Recherche joint Project No. NRF2017-NRFANR004 VanQuTe, the FQXi Large Grant: The role of quantum effects in simplifying adaptive agents and Huawei Technologies.

## Author information

K.Z., X.Z, Y.S., Y.L., and S.Z. developed the experimental system. J.T., J.M., V.V., and M.G. proposed the protocol. K.Z. implemented the protocol and led the data taking. K.K. supervised the experiment. K.Z., J.T., M.G., and K.K. wrote the manuscript.

Correspondence to Kuan Zhang or Jayne Thompson or Mile Gu or Kihwan Kim.

## Ethics declarations

### Competing interests

The authors declare no competing interests.

Peer review information Nature Communications thanks the anonymous reviewers for their contribution to the peer review of this work. Peer reviewer reports are available.

Publisher’s note Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

## Rights and permissions

Reprints and Permissions

Zhang, K., Thompson, J., Zhang, X. et al. Modular quantum computation in a trapped ion system. Nat Commun 10, 4692 (2019). https://doi.org/10.1038/s41467-019-12643-2