Modular Quantum Computation in a Trapped Ion System

TL;DR

This paper demonstrates the first modular quantum computation in a trapped ion system by implementing a quantum API that allows clients to estimate the trace of a server-provided unitary, enabling scalable and parallel quantum algorithms.

Contribution

It introduces a quantum API for modular quantum computation and demonstrates its functionality using trapped ion technology, advancing scalable quantum computing.

Findings

Successful implementation of a quantum API for trace estimation

First demonstration of modular quantum computation in a trapped ion system

Pioneering techniques for coherent qubit swapping within motional states

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 $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 \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.

Tables

Table 1. Table 1: Implementation of preprocessing. Each sequence shown in the right column implements the corresponding operation shown in the left column.

Operation	Sequence
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{0}_Y⟩+|1_C{0}_X{0}_Y⟩\right)/\sqrt{2}$	$R_0(\pi /2,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{1}_Y⟩-|1_C{1}_X{0}_Y⟩\right)/\sqrt{2}$	$R_0(\pi /2,-\pi /2)$, $R_0(\pi ,\pi /2)$, $R_{-Z}(\pi ,0)$, $R_0(\pi ,-\pi /2)$,
	$R_Y(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_{-Z}(\pi ,0)$, $R_X(\pi ,0)$, $R_{-Z}(\pi ,\pi )$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{1}_X{0}_Y⟩+|1_C{0}_X{1}_Y⟩\right)/\sqrt{2}$	$R_0(\pi /2,-\pi /2)$, $R_0(\pi ,\pi /2)$, $R_{-Z}(\pi ,0)$, $R_0(\pi ,-\pi /2)$,
	$R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_{-Z}(\pi ,0)$, $R_Y(\pi ,\pi )$, $R_{-Z}(\pi ,\pi )$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{1}_X{1}_Y⟩+|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}$	$R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_Y(\pi ,\pi )$, $R_0(\pi ,\pi /2)$, $R_0(\pi /2,-\pi /2)$

Table 2. Table 2: Implementation of postprocessing. Here α = arccos ⁡ [ csc ⁡ ( π / 2 ) / 2 ] 𝛼 𝜋 2 2 \alpha=\arccos\left[\csc(\pi/\sqrt{2})/\sqrt{2}\right] and γ = ϕ − arccos ⁡ [ cot ⁡ ( π / 2 ) ] 𝛾 italic-ϕ 𝜋 2 \gamma=\phi-\arccos\left[\cot(\pi/\sqrt{2})\right] .

Operation	Sequence
$F\left(\varphi \right)$	$R_{-Z}(\pi ,0)$,
	$R_Y(\pi ,\pi )$, $R_X(\pi /\sqrt{2},\gamma )$, $R_X(\pi /\sqrt{2},2\alpha +\gamma )$,
	$R_Z(\pi ,\pi )$, $R_{-Z}(\pi ,\pi )$, $R_Z(\pi ,0)$,
	$R_X(\pi /\sqrt{2},2\alpha +\gamma )$, $R_X(\pi /\sqrt{2},\gamma )$, $R_Y(\pi ,0)$,
	$R_Z(\pi ,\pi )$

Table 3. Table 3: Implementation of modified SWAP gate. Here α = arccos ⁡ [ csc ⁡ ( π / 2 ) ​ sin ⁡ ( χ / 4 ) ] 𝛼 𝜋 2 𝜒 4 \alpha=\arccos\left[\csc(\pi/\sqrt{2})\sin(\chi/4)\right] and γ = ϕ − arccos ⁡ [ cot ⁡ ( π / 2 ) ​ tan ⁡ ( χ / 4 ) ] 𝛾 italic-ϕ 𝜋 2 𝜒 4 \gamma=\phi-\arccos\left[\cot(\pi/\sqrt{2})\tan(\chi/4)\right] .

Operation	Sequence
$U(\chi ,\theta ,\varphi )$	$R_0(\pi /2-\theta ,\varphi +\pi /2)$, $R_0(\chi ,\varphi )$,
	$R_0(\pi /2-\theta ,\varphi -\pi /2)$
$S_X(\chi ,\varphi )$	$R_X(\pi /\sqrt{2},\gamma )$, $R_X(\sqrt{2}\pi ,2\alpha +\gamma )$,
	$R_X(\pi /\sqrt{2},\gamma )$

Table 4. Table 4: Implementation of R i subscript 𝑅 i R_{\mathrm{i}} .

Operation	Sequence
$|0_C{0}_X{0}_Y⟩\to |0_C{0}_X{1}_Y⟩$	$R_Y(\pi ,0)$, $R_0(\pi ,\pi /2)$
$|0_C{0}_X{0}_Y⟩\to |0_C{1}_X{0}_Y⟩$	$R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$
$|0_C{0}_X{0}_Y⟩\to |0_C{1}_X{1}_Y⟩$	$R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_Y(\pi ,0)$, $R_0(\pi ,\pi /2)$
$|0_C{0}_X{0}_Y⟩\to |1_C{0}_X{0}_Y⟩$	$R_0(\pi ,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to |1_C{0}_X{1}_Y⟩$	$R_Y(\pi ,0)$
$|0_C{0}_X{0}_Y⟩\to |1_C{1}_X{0}_Y⟩$	$R_X(\pi ,0)$
$|0_C{0}_X{0}_Y⟩\to |1_C{1}_X{1}_Y⟩$	$R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_Y(\pi ,0)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{0}_Y⟩+|1_C{0}_X{0}_Y⟩\right)/\sqrt{2}$	$R_0(\pi /2,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{0}_Y⟩+|1_C{0}_X{1}_Y⟩\right)/\sqrt{2}$	$R_Y(\pi /2,0)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{0}_Y⟩+|1_C{1}_X{0}_Y⟩\right)/\sqrt{2}$	$R_X(\pi /2,0)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{1}_Y⟩+|1_C{1}_X{0}_Y⟩\right)/\sqrt{2}$	$R_{-Z}(\pi /2,-\pi /2)$, $R_Y(\pi ,0)$, $R_0(\pi ,\pi /2)$,
	$R_{-Z}(\pi ,\pi /2)$, $R_X(\pi ,0)$, $R_{-Z}(\pi ,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{1}_Y⟩+|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}$	$R_Y(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_X(\pi /2,0)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{1}_X{0}_Y⟩+|1_C{0}_X{1}_Y⟩\right)/\sqrt{2}$	$R_{-Z}(\pi /2,-\pi /2)$, $R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$,
	$R_{-Z}(\pi ,\pi /2)$, $R_Y(\pi ,0)$, $R_{-Z}(\pi ,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{1}_X{0}_Y⟩+|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}$	$R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_Y(\pi /2,0)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{1}_X{1}_Y⟩+|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}$	$R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_Y(\pi ,0)$, $R_0(\pi /2,\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{0}_Y⟩+i|1_C{0}_X{0}_Y⟩\right)/\sqrt{2}$	$R_0(\pi /2,\pi )$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{0}_Y⟩+i|1_C{0}_X{1}_Y⟩\right)/\sqrt{2}$	$R_Y(\pi /2,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{0}_Y⟩+i|1_C{1}_X{0}_Y⟩\right)/\sqrt{2}$	$R_X(\pi /2,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{1}_Y⟩+i|1_C{1}_X{0}_Y⟩\right)/\sqrt{2}$	$R_{-Z}(\pi /2,-\pi /2)$, $R_Y(\pi ,0)$, $R_0(\pi ,\pi /2)$,
	$R_{-Z}(\pi ,\pi /2)$, $R_X(\pi ,-\pi /2)$, $R_{-Z}(\pi ,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{0}_X{1}_Y⟩+i|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}$	$R_Y(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_X(\pi /2,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{1}_X{0}_Y⟩+i|1_C{0}_X{1}_Y⟩\right)/\sqrt{2}$	$R_{-Z}(\pi /2,-\pi /2)$, $R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$,
	$R_{-Z}(\pi ,\pi /2)$, $R_Y(\pi ,-\pi /2)$, $R_{-Z}(\pi ,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{1}_X{0}_Y⟩+i|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}$	$R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_Y(\pi /2,-\pi /2)$
$|0_C{0}_X{0}_Y⟩\to \left(|0_C{1}_X{1}_Y⟩+i|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}$	$R_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $R_Y(\pi ,-\pi /2)$, $R_0(\pi /2,0)$

Table 5. Table 5: Implementation of R o subscript 𝑅 o R_{\mathrm{o}} .

Operation	Sequence
$|0_C{0}_X{0}_Y⟩\to |1_C{1}_X{1}_Y⟩$	$S_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $S_Y(\pi ,0)$
$|0_C{0}_X{1}_Y⟩\to |1_C{1}_X{1}_Y⟩$	$S_X(\pi ,0)$
$|0_C{1}_X{0}_Y⟩\to |1_C{1}_X{1}_Y⟩$	$S_Y(\pi ,0)$
$|0_C{1}_X{1}_Y⟩\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi ,-\pi /2)$
$|1_C{0}_X{0}_Y⟩\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi ,\pi /2)$, $S_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $S_Y(\pi ,0)$
$|1_C{0}_X{1}_Y⟩\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi ,\pi /2)$, $S_X(\pi ,0)$
$|1_C{1}_X{0}_Y⟩\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi ,\pi /2)$, $S_Y(\pi ,0)$
$\left(|0_C{0}_X{0}_Y⟩+|1_C{0}_X{0}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi /2,\pi /2)$, $S_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $S_Y(\pi ,0)$
$\left(|0_C{0}_X{0}_Y⟩+|1_C{0}_X{1}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$S_Y(\pi /2,0)$, $R_0(\pi ,\pi /2)$, $S_X(\pi ,0)$
$\left(|0_C{0}_X{0}_Y⟩+|1_C{1}_X{0}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$S_X(\pi /2,0)$, $R_0(\pi ,\pi /2)$, $S_Y(\pi ,0)$
$\left(|0_C{0}_X{1}_Y⟩+|1_C{0}_X{1}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi /2,\pi /2)$, $S_X(\pi ,0)$
$\left(|0_C{0}_X{1}_Y⟩+|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$S_X(\pi /2,0)$
$\left(|0_C{1}_X{0}_Y⟩+|1_C{1}_X{0}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi /2,\pi /2)$, $S_Y(\pi ,0)$
$\left(|0_C{1}_X{0}_Y⟩+|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$S_Y(\pi /2,0)$
$\left(|0_C{1}_X{1}_Y⟩+|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi /2,-\pi /2)$
$\left(|0_C{0}_X{0}_Y⟩+i|1_C{0}_X{0}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi /2,0)$, $S_X(\pi ,0)$, $R_0(\pi ,\pi /2)$, $S_Y(\pi ,0)$
$\left(|0_C{0}_X{0}_Y⟩+i|1_C{0}_X{1}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$S_Y(\pi /2,-\pi /2)$, $R_0(\pi ,\pi /2)$, $S_X(\pi ,0)$
$\left(|0_C{0}_X{0}_Y⟩+i|1_C{1}_X{0}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$S_X(\pi /2,-\pi /2)$, $R_0(\pi ,\pi /2)$, $S_Y(\pi ,0)$
$\left(|0_C{0}_X{1}_Y⟩+i|1_C{0}_X{1}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi /2,0)$, $S_X(\pi ,0)$
$\left(|0_C{0}_X{1}_Y⟩+i|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$S_X(\pi /2,-\pi /2)$
$\left(|0_C{1}_X{0}_Y⟩+i|1_C{1}_X{0}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi /2,0)$, $S_Y(\pi ,0)$
$\left(|0_C{1}_X{0}_Y⟩+i|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$S_Y(\pi /2,-\pi /2)$
$\left(|0_C{1}_X{1}_Y⟩+i|1_C{1}_X{1}_Y⟩\right)/\sqrt{2}\to |1_C{1}_X{1}_Y⟩$	$R_0(\pi /2,\pi )$

Table 6. Table 6: Implementation of | 1 C ​ 1 X ​ 1 Y ⟩ ket subscript 1 C subscript 1 X subscript 1 Y \ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}} measurement. Here | 1 C ​ 1 X ​ 1 Y ⟩ → | 0 C ⟩ → ket subscript 1 C subscript 1 X subscript 1 Y ket subscript 0 C \ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}\rightarrow\ket{0_{\mathrm{C}}} stands for a operation that transforms only | 1 C ​ 1 X ​ 1 Y ⟩ ket subscript 1 C subscript 1 X subscript 1 Y \ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}} to | 0 C ⟩ ket subscript 0 C \ket{0_{\mathrm{C}}} , and all other 7 base states to | 1 C ⟩ ket subscript 1 C \ket{1_{\mathrm{C}}} .

Operation	Sequence
$P_X\left(\varphi \right)$	$R_X(\pi /2,\varphi )$, $R_X(\pi /\sqrt{2},\varphi +\pi /2)$, $R_X(\pi /2,\varphi )$
$P_Y\left(\varphi \right)$	$R_Y(\pi /2,\varphi )$, $R_Y(\pi /\sqrt{2},\varphi +\pi /2)$, $R_Y(\pi /2,\varphi )$
$|1_C{1}_X{1}_Y⟩\to |0_C⟩$	$P_X\left(0\right)$, $R_0(\pi ,-\pi /2)$, $P_Y\left(0\right)$

Equations

$$\rho_{\mathrm{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).$$

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

$$R_0(\chi ,\varphi )=$$

$$R_{\pm \mathrm{Z}}(\chi ,\varphi )=$$

$$R_{\mathrm{X}}(\chi ,\varphi )=$$

$$R_{\mathrm{Y}}(\chi ,\varphi )=$$

$$|{\psi }_{l,m}⟩=(|0_{\mathrm{C}}{l}_{\mathrm{X}}{m}_{\mathrm{Y}}⟩+|1_{\mathrm{C}}{m}_{\mathrm{X}}{l}_{\mathrm{Y}}⟩)/\sqrt{2}.$$

$$|0_{\mathrm{C}}{0}_{\mathrm{X}}{0}_{\mathrm{Y}}⟩\to$$

$$\to$$

$$|0_{\mathrm{C}}{0}_{\mathrm{X}}{0}_{\mathrm{Y}}⟩\to$$

$$\to$$

$$|0_{\mathrm{C}}{0}_{\mathrm{X}}{0}_{\mathrm{Y}}⟩\to$$

$$\to$$

$${\rho }_1^{\prime }=\frac{1}{4}\sum _{l,m=0}^1|{\psi }_{l,m}^{\prime }⟩⟨{\psi }_{l,m}^{\prime }|=Z_1^{†}{\rho }_1{Z}_1,$$

$$Z_1=\mathrm{Diag}\left(1,1,1,1,1,-1,1,1\right),$$

$$S_{\mathrm{X}}(\chi,\phi)=\left(\begin{array}[]{cccc}\cos\frac{\chi}{2}&&&-\sin\frac{\chi}{2}e^{i\phi}\\ &1\\ &&1\\ \sin\frac{\chi}{2}e^{-i\phi}&&&\cos\frac{\chi}{2}\end{array}\right)$$

$$S_{\mathrm{X}}(\pi ,\pi )U_{\mathrm{C}}{S}_{\mathrm{X}}(\pi ,0)=Z_2{U}_{\mathrm{X}}^{\ast }{Z}_2^{†},$$

$$Z_2=\mathrm{Diag}\left(1,-1,1,1\right)$$

$$F(\phi)=\left(\begin{array}[]{cccccccc}1\\ &1\\ &&1\\ &&&1\\ &&&&1\\ &&&&&&-e^{i\phi}\\ &&&&&e^{-i\phi}\\ &&&&&&&1\end{array}\right)$$

$$Z_3=\mathrm{Diag}(1,1,1,1,1,-1,1,1)$$

$$U=\exp \left(-i\frac{\chi }{2}{\sigma }_{\theta ,\varphi }\right)$$

$$\sigma_{\theta,\phi}=\left(\begin{array}[]{cc}-\cos\theta&\sin\theta e^{i\phi}\\ \sin\theta e^{-i\phi}&\cos\theta\end{array}\right)$$

$$\begin{array}[]{rl}\rho^{\prime}_{3}=&F_{0}Z_{1}Z_{2}U_{\mathrm{X}}Z_{2}^{\dagger}Z_{1}^{\dagger}F_{0}\left(\begin{array}[]{cc}I&I\\ I&I\end{array}\right)\\ &F_{0}Z_{1}Z_{2}U_{\mathrm{X}}^{\dagger}Z_{2}^{\dagger}Z_{1}^{\dagger}F_{0}/N^{\prime}\\ =&\frac{1}{N^{\prime}}\Lambda F_{0}U_{\mathrm{X}}F_{0}\Lambda^{\dagger}\left(\begin{array}[]{cc}I&I\\ I&I\end{array}\right)\Lambda F_{0}U_{\mathrm{X}}^{\dagger}F_{0}\Lambda^{\dagger}\\ =&\left(\begin{array}[]{cc}\Lambda_{0}U_{\mathrm{X}}\Lambda_{0}^{\dagger}\\ &\Lambda_{1}U_{\mathrm{Y}}\Lambda_{1}^{\dagger}\end{array}\right)\left(\begin{array}[]{cc}I&I\\ I&I\end{array}\right)\\ &\left(\begin{array}[]{cc}\Lambda_{0}U_{\mathrm{X}}^{\dagger}\Lambda_{0}^{\dagger}\\ &\Lambda_{1}U_{\mathrm{Y}}^{\dagger}\Lambda_{1}^{\dagger}\end{array}\right)/N^{\prime}\\ =&\frac{1}{N^{\prime}}\left(\begin{array}[]{cc}I&\Lambda_{0}U_{\mathrm{X}}\Lambda_{0}^{\dagger}\Lambda_{1}U_{\mathrm{Y}}^{\dagger}\Lambda_{1}^{\dagger}\\ \Lambda_{1}U_{\mathrm{Y}}\Lambda_{1}^{\dagger}\Lambda_{0}U_{\mathrm{X}}^{\dagger}\Lambda_{0}^{\dagger}&I\end{array}\right)\end{array}$$

$$\Lambda=F_{0}Z_{1}Z_{2}F_{0}=\left(\begin{array}[]{cc}\Lambda_{0}\\ &\Lambda_{1}\end{array}\right)$$

$$\begin{array}[]{rl}\langle\sigma_{1}\rangle=&\mathrm{tr}\left(\Lambda_{0}U_{\mathrm{X}}\Lambda_{0}^{\dagger}\Lambda_{1}U_{\mathrm{Y}}^{\dagger}\Lambda_{1}^{\dagger}+\mathrm{h.c.}\right)/N^{\prime}\\ =&\sum_{l,m}\bra{l}\Lambda_{0}U_{\mathrm{X}}\Lambda_{0}^{\dagger}\ket{m}\bra{m}\Lambda_{1}U_{\mathrm{Y}}^{\dagger}\Lambda_{1}^{\dagger}\ket{l}/N^{\prime}+\mathrm{h.c.}\\ =&\sum_{m}\bra{m}U_{\mathrm{X}}\ket{m}\bra{m}U_{\mathrm{Y}}^{\dagger}\ket{m}/N^{\prime}+\mathrm{h.c.}\\ =&\mathrm{tr}(U\otimes U^{\dagger}+U^{\dagger}\otimes U)/(2N)\\ =&|\mathrm{tr}(U)/N|^{2},\end{array}$$

$$|⟨\phi |F(0)|\psi ⟩{|}^2=|⟨1_{\mathrm{C}}{1}_{\mathrm{X}}{1}_{\mathrm{Y}}|R_{\mathrm{o}}F(0)R_{\mathrm{i}}|0_{\mathrm{C}}{0}_{\mathrm{X}}{0}_{\mathrm{Y}}⟩{|}^2$$

$$\displaystyle\begin{array}[]{rl}&\left|\left(\bra{l}+\bra{k}\right)F(0)\ket{\psi}\right|^{2}-\\ &\left(\left|\bra{l}F(0)\ket{\psi}\right|^{2}+\left|\bra{k}F(0)\ket{\psi}\right|^{2}\right)\\ =&\bra{l}F(0)\ket{\psi}\bra{\psi}F(0)\ket{k}+\mathrm{h.c.}\end{array}$$

$$\displaystyle\begin{array}[]{rl}&\left|\left(\bra{l}-i\bra{k}\right)F(0)\ket{\psi}\right|^{2}-\\ &\left(\left|\bra{l}F(0)\ket{\psi}\right|^{2}+\left|\bra{k}F(0)\ket{\psi}\right|^{2}\right)\\ =&i\bra{l}F(0)\ket{\psi}\bra{\psi}F(0)\ket{k}-\mathrm{h.c.}\end{array}$$

$$\arg \frac{⟨k|F(0)|q⟩}{⟨l|F(0)|m⟩}\approx \arg \frac{⟨k|F(0)|\psi ⟩}{⟨l|F(0)|\psi ⟩}=\arctan \frac{(\text{ref}eq:phase2)}{(\text{ref}eq:phase1)}.$$

Full text

††preprint: APS/123-QED

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)=\mathrm{tr}(U)/2^{n}$ by calling on Bob’s service as a sub-routine. 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 DQC1 knill1998power , cannot operate by offloading synthesis of $U$ to a third party (see Fig. 1 a). Indeed, the design of devices that realize complex $U$-dependent processes, given some unknown $U$, has received considerable attention chiribella2009theoretical ; chiribella2008quantum ; chiribella2008transforming ; pollock2018non ; kretschmann2005quantum ; aharonov2009multiple ; hardy2012operator ; costa2016quantum ; allen2017quantum . In this context, several no-go results have been established chiribella2013quantum ; araujo2014quantum ; miyazaki2017universal ; friis2014implementing ; thompson2018quantum , motivating recent works in identifying what sacrifices or restrictions are necessary to circumvent these no-go theorems friis2014implementing ; thompson2018quantum ; lloyd2014quantum ; sheridan2009approximating ; nakayama2015quantum ; friis2017flexible ; zhou2011adding .

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 party thompson2018quantum . 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 CSWAP gate – coherently swap two motional modes of an ion trapped in a 3D 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 gates shor1999polynomial . This presents the first demonstration of a modular quantum algorithm and provides an important step towards collaborative quantum computing.

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 Note1 (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 impossible friis2014implementing ; thompson2018quantum . 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. 1 b):

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 $\ket{+}=(\ket{0}+\ket{1})/\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}=\ket{0}\bra{1}+\ket{1}\bra{0}$ basis then has expectation value of $|T(U)|^{2}$, enabling efficient estimation of $|T(U)|$. Further details are shown in Fig. 1 b.

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}\mathrm{Yb}^{+}~{}$ion in a harmonic potential when $n=1$. In this special case, the protocol involves a system of three qubits. Qubit $\mathrm{C}$ represents the control, which is encoded into the internal states of ${}^{171}\mathrm{Yb}^{+}~{}$. Two registers, denoted as qubits $\mathrm{X}$ and $\mathrm{Y}$, are encoded into the external motional levels of ${}^{171}\mathrm{Yb}^{+}~{}$. Unitary operations on qubit $\mathrm{C}$ are performed by applying resonant microwaves zhang2015time ; shen2017quantum . Meanwhile entangling gates between the ancilla and the two registers are realized by applying counter-propagating Raman laser beams with appropriate frequency differences and phases leibfried2003quantum ; gulde2003implementation ; Hsiang2015Spin ; Ding2017Cross ; zhang2018operational .

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 $\mathrm{C}$ and qubit $\mathrm{X}$. The actions of these SWAP gates have no effect on the algorithms output, but benefit this particular setup, 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 $\mathrm{C}$ directly – with understanding that in more realistic scenarios, information within $\mathrm{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 controlled swap (CSWAP) gate on registers $\mathrm{X}$ and $\mathrm{Y}$ with qubit $\mathrm{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 materials A). Subsequently, a second SWAP is then used to interchange information between $\mathrm{X}$ and $\mathrm{C}$ – enabling $\mathrm{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 materials A). Appropriately configured measurements on qubit $\mathrm{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 fidelity patel2016quantum ) of $0.85\pm 0.02$ (see supplementary materials C 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:

Alice performs relevant pre-processing and walks away from her lab. 2. 2.

Bob then implements $U$ on $\mathrm{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 approximately 0.02.

We compare these experimental results to their theoretical predictions in Fig. 4 a. 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 bench-marking her device against an ‘identity server’ (e.g. preforming pre-processing and post-processing 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. 4 b. 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 analogue 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 favourable means of scaling than encoding qubits only within the internal states of ions. In supplementary materials A, 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 detection liu2018quantum , and quantum computing with continuous variable encodings lau2016universal .

Methods

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

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

$\mathcal{I}_{out}=(S_{out},\mathcal{H}_{out},\mathcal{B}_{out})$ consisting of the exact physical system $S_{out}$, Hilbert space $\mathcal{H}_{out}$ and computational basis $\mathcal{B}_{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 $\ket{\phi}$ encoded within $\mathcal{I}_{in}$, Bob will return $U\ket{\phi}$ encoded within $\mathcal{I}_{out}$. Note that in many settings, our experiment included, $\mathcal{I}_{in}=\mathcal{I}_{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

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_{in}$ and wait for reception of $S_{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 $\mathrm{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 soft-ware 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 setup. Specifically, the expected output state of the circuit immediately prior to the measurement is

[TABLE]

Measurement in Pauli-X basis then yields the desired expectation value of $\langle\sigma_{1}\rangle_{\mathrm{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

[TABLE]

in place of $\rho_{\mathrm{ideal}}$, where $0\leq 1-\lambda\leq 1$ benchmarks the level of effective decoherence. Subsequent Pauli-X yields expectation values $\langle\sigma_{1}\rangle_{\mathrm{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)|^{2}_{\mathrm{est}}=\langle\sigma_{1}\rangle_{\mathrm{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.

Acknowledgments

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 authors acknowledge support by the National Research Foundation of Singapore (Fellowship NRF-NRFF2016-02), the John Templeton Foundation (grant 53914), and the National Research Foundation and L’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

Author contributions

K.Z., X.Z, Y.S., 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.

Corresponding author

Correspondence to Kuan Zhang, Jayne Thompson, Mile Gu and Kihwan Kim

Competing financial interests

The authors declare no competing financial interests.

Appendix A Experimental Details

Our experiment consists of three logical qubits: The control qubit $\mathrm{C}$ that is encoded within the hyperfine levels of an ${}^{171}\mathrm{Yb}^{+}~{}$ion and the reservoir qubits $\mathrm{X}$ and $\mathrm{Y}$ that correspond the ground and first excited states of the ion’s two motional degrees of freedom. Operations on $\mathrm{C}$ are enabled by microwave pulses, which inact the Hamiltonians

[TABLE]

Here the carrier operation $R_{0}(\chi,\phi)$ drives the coupling $\ket{0_{\mathrm{C}}}\leftrightarrow\ket{1_{\mathrm{C}}}$, meanwhile the Zeeman operations $R_{\pm\mathrm{Z}}(\chi,\phi)$ drive the coupling $\ket{0_{\mathrm{C}}}\leftrightarrow\ket{\pm\mathrm{Z}_{\mathrm{C}}}$ resonantly. Coupling with $\mathrm{X}$ and $\mathrm{Y}$ are enabled by counter-propagating Raman laser beams, which execute blue sideband operations between hyperfine and motional levels

[TABLE]

where $\sigma_{+}=\ket{1_{\mathrm{C}}}\bra{0_{\mathrm{C}}}$, $\sigma_{-}=\ket{0_{\mathrm{C}}}\bra{1_{\mathrm{C}}}$, $a_{\mathrm{X}}$ ($a_{\mathrm{X}}^{\dagger}$) and $a_{\mathrm{Y}}$ ($a_{\mathrm{Y}}^{\dagger}$) are the annihilation (creation) operators of motional modes $\mathrm{X}$ and $\mathrm{Y}$. We proceed to describe the experimental details for realizing (i) preprocessing, (ii) postprocessing and (iii) the actions of the server.

Preprocessing – We engineer the required mixed state $\rho_{1}$ by building 4 separate 3-qubit quantum circuits $\mathcal{C}_{l,m}$, such that the action of $\mathcal{C}_{l,m}$ converts $\ket{0}_{C}\ket{0}_{X}\ket{0}_{Y}$ to $\ket{\phi_{l,m}}$, where

[TABLE]

A diagram of each circuit is depicted in Fig. 5. Algebraically, the actions can be described as

[TABLE]

An equal statistical mixing of these four states then gives us the mixed state

[TABLE]

where the phase shift

[TABLE]

caused by the minus sign of $\ket{\psi^{\prime}_{0,1}}$ in Eq. (10), has no effect on the results (See Sec. B). The detailed of implementation of each process is shown in Tab. 1.

The final element of the preprocessing is to map information between $\mathrm{X}$ and $\mathrm{C}$, for delivery to the server. In the theoretical protocol, this is achieved by a SWAP gate between $\mathrm{X}$ and $\mathrm{C}$. While this gate is difficult to achieve in our ion trap setup, we developed a suitable sequence of Raman operations (see Tab. 3) that implement the class of two-qubits operations

[TABLE]

with basis $\ket{0_{\mathrm{C}}0_{\mathrm{X}}}$, $\ket{1_{\mathrm{C}}0_{\mathrm{X}}}$, $\ket{0_{\mathrm{C}}1_{\mathrm{X}}}$ and $\ket{1_{\mathrm{C}}1_{\mathrm{X}}}$ that works as a suitable replacement – provided a suitably modified SWAP gate is also used during post-processing.

To see this, let $U_{\mathrm{C}}$ denotes action of $U$ on qubit $\mathrm{C}$, $U_{\mathrm{X}}$ the action of $U$ on qubit $\mathrm{X}$. We then observe that

[TABLE]

where the phase shift

[TABLE]

has no effect on measurement results (See Sec. B for proof), and $U^{*}$ has the same effect on the results as $U$, since $|\mathrm{tr}(U^{*})|=|\mathrm{tr}(U)|$. Thus during pre-processing stage, Alice replaces the SWAP gate with the gate $S_{\mathrm{X}}(\pi,0)$. Once done, Alice can out-source qubit $\mathrm{C}$ to a third party for realization of $U$.

Postprocessing – The postprocessing module consists of two steps. The first is to perform a suitably modified SWAP gate between $\mathrm{C}$ and $\mathrm{X}$. This is done by realization of the gate $S_{\mathrm{X}}(\pi,\pi)$ (again using the pulse sequence given in Tab. 3).

The second step is application of a CSWAP gate on $\mathrm{X}$ and $\mathrm{Y}$ using qubit $\mathrm{C}$ as a control. To do this, we first develop a means of implementing the following $3$ qubit gate

[TABLE]

with basis $\ket{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}$, $\ket{0_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}$, $\cdots$, $\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$. Specifically, when qubit $\mathrm{C}$ is in state $\ket{0_{\mathrm{C}}}$, it is temporarily shelved into Zeeman levels $\ket{\pm\mathrm{Z}_{\mathrm{C}}}$. We first transfer $\ket{0_{\mathrm{C}}}$ to $\ket{-\mathrm{Z}_{\mathrm{C}}}$ by $R_{-\mathrm{Z}}(\pi,0)$ in the beginning. At halfway, $\ket{-\mathrm{Z}_{\mathrm{C}}}$ is transferred to $\ket{\mathrm{Z}_{\mathrm{C}}}$ by sequence $R_{\mathrm{Z}}(\pi,\pi)$, $R_{-\mathrm{Z}}(\pi,\pi)$, $R_{\mathrm{Z}}(\pi,0)$. Finally, we transfer $\ket{\mathrm{Z}_{\mathrm{C}}}$ back to $\ket{0_{\mathrm{C}}}$ by $R_{\mathrm{Z}}(\pi,\pi)$ in the end. When qubit $\mathrm{C}$ is in state $\ket{1_{\mathrm{C}}}$, a swap of populations between $\ket{1_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}$ and $\ket{1_{\mathrm{C}}1_{\mathrm{X}}0_{\mathrm{Y}}}$ is executed by sequence $R_{\mathrm{Y}}(\pi,\pi)$, $S_{\mathrm{X}}(\pi,\phi)$, $R_{\mathrm{Y}}(\pi,0)$. The full implementation of $F(\phi)$ is shown in Tab. 2.

During postprocessing, we perform operation $F(0)=F_{0}Z_{3}$, where $F_{0}$ is a standard CSWAP gate, and the phase shift

[TABLE]

has no effect on the results (proved in Sec. B).

The final step – a $\sigma_{1}$ measurement on qubit $\mathrm{C}$ – is realized by sequentially applying Hadamard gate and standard fluorescence detection.

Benchmarking – To benchmark the modular DQC1 protocol, we take on the role of the server, Bob, who is out-sourced by Alice to apply a unitary $U$ on qubit $\mathrm{C}$ before returning it to Alice for postprocessing.

To test modularity, we needed to ensure that Alice’s device could correctly estimate $|T(U)|$ for any possible $U$ without modification. As such, in experiment, our simulation of the server needs to synthesize a wide variety of possible $U$. To do this, we developed a generic scheme for synthesizing

[TABLE]

where

[TABLE]

for general values of $\chi$, $\theta$ and $\phi$ using microwave operations (see Tab. 3).

In the experiment, we benchmarked Alice for 19 different choices of $U$. For each choice, we executed $1000$ runs for each possible choice of $l$ and $m$, resulting in a total of $4000$ runs. Thus in total, the experiment involved $4\times 19\times 1000=76000$ measurements.

Potential Scalability – Here we outline a potential means for scaling our postprocessing and preprocessing modules so that they may be used to build a modular DQC1 algorithm that evaluates $|T(U)|$ for some $2^{n}\times 2^{n}$ unitary. Recall that such a algorithm involves 1 control qubit $\mathrm{C}$, together with two $2^{n}$-dimensional registers, $\mathrm{X}$ and $\mathrm{Y}$.

Consider encoding each $2^{n}$-dimensional register to the ground and first excited states of $n$ motional modes. For each $2^{n}$-dimensional register, we can label the elements of a complete basis by $n$-bit binary strings, such that the $\mathrm{X}$ register basis is indexed by $l=l_{n-1}\cdots{l_{1}l_{0}}$ and the $\mathrm{Y}$ register is indexed by $m=m_{n-1}\cdots{m_{1}m_{0}}$.

To scale the preprocessing module up, we start by generating two $n$-bit binary strings at random, then we synthesize the circuit $\mathcal{C}_{l,m}$ described by Fig. 6. Meanwhile the postprocessing module can be scaled up to the general case of two $2^{n}$-dimensional registers by repeatedly conducting $F(0)$ (see Fig. 7).

If Alice repeats the above for each call to the server, and after $K$ calls (where K scales as polynomial of $n$), we are then able to estimate $|T(U)|$ to some fixed accuracy.

Appendix B Invariance to Phase Shifts

Observe that in our implementation, many operations are synthesized up to some phase shift. Here we prove that these phase shifts, namely the phase gates, $Z_{1}$, $Z_{2}$ and $Z_{3}$ (see Eq. (16)(19)(21)), have no effect on theoretical expectation value $\langle\sigma_{1}\rangle$. In fact, the above conclusion is true for general $n$, as long as $Z_{1}=Z_{3}$. In this case, the state before measurement is

[TABLE]

with basis $\ket{0_{\mathrm{C}}}$ and $\ket{1_{\mathrm{C}}}$, where $I$ is the identity matrix,

[TABLE]

has only eigenvalues of $\pm 1$, and $N^{\prime}$ is the dimension of system. For general $n$, the client possesses 1 control qubit and 2 registers, and the server possesses 1 register. Thus $N^{\prime}=2N^{3}$. In our special case, the control qubit serves as server register. Thus $N^{\prime}=8$.

We derive the expectation value $\langle\sigma_{1}\rangle$ of $\rho^{\prime}_{3}$

[TABLE]

where $\ket{l}=\ket{m}$ (if $\ket{l}\neq\ket{m}$, then $\bra{l}U_{\mathrm{X}}\ket{m}=0$ or $\bra{l}U_{\mathrm{Y}}\ket{m}=0$) traverses the $N^{\prime}$ eigenstates of $\Lambda$, and $U$ is an $N\times{N}$ matrix. Thus we prove our conclusion.

Appendix C Performance of CSWAP gate

The theoretical result of $F(0)$ is defined in Eq. (20). In experiment, we obtain the absolute value of each matrix element of $F(0)$. We also obtain the phase of any element that has a absolute value of 1 in theory. These are all done by measuring population $|\bra{\varphi}F(0)\ket{\psi}|^{2}$ for necessary inputs $\ket{\psi}$ and outputs $\ket{\varphi}$. The resulting outcomes are depicted in Fig. 8. Each measurement

[TABLE]

consists of the foolowing 5 steps. First, we prepare $\ket{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}$ by standard sideband cooling. Second, we conduct $R_{\mathrm{i}}$, which prepares $\ket{\psi}$ from $\ket{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}$ (see Tab. 4). Third is $F(0)$. Fourth is $R_{\mathrm{i}}$, which transforms output $\ket{\varphi}$ to $\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$ (see Tab. 5). And the last is the population measurement of $\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$ (see Tab. 6).

To measure the population of $\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$, we develop $P_{\mathrm{X}}(\phi)$ operation that instigates $\pi$ transitions for both $\ket{0_{\mathrm{C}}0_{\mathrm{X}}}\leftrightarrow\ket{1_{\mathrm{C}}1_{\mathrm{X}}}$ and $\ket{0_{\mathrm{C}}1_{\mathrm{X}}}\leftrightarrow\ket{1_{\mathrm{C}}2_{\mathrm{X}}}$, and $P_{\mathrm{Y}}(\phi)$ operation which is defined similarly (see Tab. 6). By a proper sequence that involves $P_{\mathrm{X}}(0)$ and $P_{\mathrm{Y}}(0)$, we are able to transforms $\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$ to $\ket{0_{\mathrm{C}}}$, and $\ket{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}$, $\ket{0_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}$, $\cdots$, $\ket{1_{\mathrm{C}}1_{\mathrm{X}}0_{\mathrm{Y}}}$ to $\ket{1_{\mathrm{C}}}$ (see Tab. 6). After this sequence, $\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$ population measurement can then be completed by measuring the population of $\ket{0_{\mathrm{C}}}$, which is realized by standard fluorescence detection and detection error correction. We note that, our method of $\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$ measurement works only for the state that not populates $\ket{(l>1)_{\mathrm{X}}}$ and $\ket{(m>1)_{\mathrm{Y}}}$. Our protocol naturally ensures that $F(0)\ket{\psi}$ fulfills this condition. To make $R_{\mathrm{o}}F(0)\ket{\psi}$ still fulfills, we cannot use $R_{\mathrm{X}}$ and $R_{\mathrm{Y}}$ for the implementation of $R_{\mathrm{o}}$. Instead, we use $S_{\mathrm{X}}$ (see Eq. (17)), and $S_{\mathrm{Y}}$, which works on $\mathrm{Y}$ mode and qubit $\mathrm{C}$ similar to $S_{\mathrm{X}}$.

In experiment, we first let $\ket{\varphi}$ and $\ket{\psi}$ traverse $\ket{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}$, $\ket{0_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}$, $\cdots$, $\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$. Hence, we obtain the absolute value of each matrix element of $F(0)$ by square root. Then we obtain the phase of any element as follows. For any base states $\ket{l}$ and $\ket{k}$, by letting $\ket{\varphi}$ traverse $\ket{l}$, $\ket{k}$, $(\ket{l}+\ket{k})/\sqrt{2}$ and $(\ket{l}+i\ket{k})/\sqrt{2}$, we can obtain

[TABLE]

Supposing $\bra{l}F(0)\ket{m}$ and $\bra{k}F(0)\ket{q}$ are matrix elements that satisfy $|\bra{l}F(0)\ket{m}|=|\bra{k}F(0)\ket{q}|=1$ in theory, by letting $\ket{\psi}=(\ket{m}+e^{i\phi}\ket{q})/\sqrt{2}$, we have

[TABLE]

In practice, we let $\ket{\psi}$ traverse $(\ket{m}+\ket{q})/\sqrt{2}$ and $(\ket{m}+i\ket{q})/\sqrt{2}$, and average their results of Eq. (36). We define the phase of $\bra{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}F(0)\ket{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}$ to be 0, and measure the relative phases between $\bra{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}F(0)\ket{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}$ and $\bra{1_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}F(0)\ket{1_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}$, $\bra{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}F(0)\ket{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}$ and $\bra{1_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}F(0)\ket{1_{\mathrm{C}}1_{\mathrm{X}}0_{\mathrm{Y}}}$, $\bra{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}F(0)\ket{0_{\mathrm{C}}0_{\mathrm{X}}0_{\mathrm{Y}}}$ and $\bra{1_{\mathrm{C}}1_{\mathrm{X}}0_{\mathrm{Y}}}F(0)\ket{1_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}$, $\bra{0_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}F(0)\ket{0_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}$ and $\bra{1_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}F(0)\ket{1_{\mathrm{C}}1_{\mathrm{X}}0_{\mathrm{Y}}}$, $\bra{0_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}F(0)\ket{0_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}$ and $\bra{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}F(0)\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$, $\bra{0_{\mathrm{C}}1_{\mathrm{X}}0_{\mathrm{Y}}}F(0)\ket{0_{\mathrm{C}}1_{\mathrm{X}}0_{\mathrm{Y}}}$ and $\bra{1_{\mathrm{C}}1_{\mathrm{X}}0_{\mathrm{Y}}}F(0)\ket{1_{\mathrm{C}}0_{\mathrm{X}}1_{\mathrm{Y}}}$, $\bra{0_{\mathrm{C}}1_{\mathrm{X}}0_{\mathrm{Y}}}F(0)\ket{0_{\mathrm{C}}1_{\mathrm{X}}0_{\mathrm{Y}}}$ and $\bra{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}F(0)\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$, $\bra{0_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}F(0)\ket{0_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$ and $\bra{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}F(0)\ket{1_{\mathrm{C}}1_{\mathrm{X}}1_{\mathrm{Y}}}$. Thus we have the phases of all 8 major elements.