Parallel quantum trajectories via forking for sampling without redundancy

TL;DR

This paper introduces a quantum forking framework that enables parallel sampling from independent quantum processes, reducing redundant state preparations and accelerating quantum tasks like channel implementation and entanglement analysis.

Contribution

The paper presents a novel quantum forking method that allows simultaneous sampling from multiple quantum trajectories, improving efficiency in quantum computations.

Findings

Demonstrated quantum forking on IBM and Rigetti platforms.

Achieved efficient implementation of non-unitary quantum channels.

Enabled advanced studies of entanglement and quantum control.

Abstract

The computational cost of preparing a quantum state can be substantial depending on the structure of data to be encoded. Many quantum algorithms require repeated sampling to find the answer, mandating reconstruction of the same input state for every execution of an algorithm. Thus, the advantage of quantum computation can diminish due to redundant state initialization. We present a framework based on quantum forking that bypasses this fundamental issue and expedites a family of tasks that require sampling from independent quantum processes. Quantum forking propagates an input state to multiple quantum trajectories in superposition, and a weighted power sum of individual results from each trajectories is obtained in one measurement via quantum interference. The significance of our work is demonstrated via applications to implementing non-unitary quantum channels, studying entanglement and benchmarking quantum control. A proof-of-principle experiment is implemented on the IBM and Rigetti quantum cloud platforms.

Equations

$$|\Psi ⟩=$$

$$+$$

$$|\Psi ⟩=$$

$$+$$

$$\sum _{i=1}^d{p}_i\prod _{j=1}^q⟨M_{i,j}⟩,$$

$$|{\Phi }_1⟩=\frac{|0⟩|\psi ⟩|\varphi ⟩+|1⟩|\varphi ⟩|\psi ⟩}{\sqrt{2}}.$$

$$|{\Phi }_2⟩=\frac{|0⟩U_1|\psi ⟩U_2|\varphi ⟩+|1⟩U_1|\varphi ⟩U_2|\psi ⟩}{\sqrt{2}}.$$

$$|{\Phi }_f⟩=\frac{|0⟩U_1|\psi ⟩U_2|\varphi ⟩+|1⟩U_2|\psi ⟩U_1|\varphi ⟩}{\sqrt{2}}.$$

$$⟨M⟩$$

$$\displaystyle=\frac{1}{2}\big{(}\langle 0|0\rangle\langle M_{1}\rangle\langle\phi|U_{2}^{{\dagger}}U_{2}|\phi\rangle+\langle 1|1\rangle\langle M_{2}\rangle\langle\phi|U_{1}^{{\dagger}}U_{1}|\phi\rangle\big{)}$$

$$=\frac{1}{2}\left(⟨M_1⟩+⟨M_2⟩\right),$$

$$⟨M⟩=$$

$$=$$

$$|{\Psi }_f⟩=\frac{1}{\sqrt{2}}\left(|0⟩U_1|\psi ⟩U_1|\psi ⟩U_2|{\varphi }_1⟩U_2|{\varphi }_2⟩+|1⟩U_2|\psi ⟩U_2|\psi ⟩U_1|{\varphi }_1⟩U_1|{\varphi }_2⟩\right).$$

$$⟨M\otimes M⟩=$$

$$=$$

$$\displaystyle+\langle 1|1\rangle\langle\psi|M_{2}|\psi\rangle\langle\psi|M_{2}|\psi\rangle\langle\phi_{1}|U_{1}^{\dagger}U_{1}|\phi_{1}\rangle\langle\phi_{2}|U_{1}^{\dagger}U_{1}|\phi_{2}\rangle\big{)}$$

$$=$$

$${\rho }_i=\sum _{j,k}^d\sqrt{p_j{p}_k}|j⟩⟨k|\otimes {\rho }_{\psi }^{\otimes q}\otimes {\rho }_{\varphi },$$

$${\rho }_f=\sum _j^d{p}_j|j⟩⟨j|\otimes {\Lambda }_j({\rho }_{\psi }{)}^{\otimes q}\otimes {\rho }_j+\sum _{j\ne k}^d\sum _j^d\sqrt{p_j{p}_k}|j⟩⟨k|\otimes \dots ,$$

$$\text{Pr}(m|{\rho }_f)$$

$$=\sum _i{p}_i\prod _j^q\text{tr}\left[{\Pi }_{j,m}{\Lambda }_i\left({\rho }_{\psi }\right)\right]$$

$$=\sum _i{p}_i\prod _j^q\text{Pr}\left[m|{\Lambda }_i\left({\rho }_{\psi }\right),j\right].$$

$$\text{tr}\left[\left(1\mathrm{l}\otimes A\otimes {1\mathrm{l}}^{\otimes d-1}\right){\rho }_f\right]=\sum _i^d{p}_i\text{tr}\left(A{U}_i{\rho }_{\psi }{U}_i^{†}\right)$$

$$=\text{tr}\left(A\sum _{i=1}^d{p}_i{U}_i{\rho }_{\psi }{U}_i^{†}\right)=\text{tr}\left[A\Phi \left({\rho }_{\psi }\right)\right],$$

$$\overline{\Lambda }(\rho )=\sum _{i=1}^d{p}_i{U}_i^{†}\Lambda \left(U_i\rho U_i^{†}\right)U_i.$$

$${\rho }_f=\sum _i^d{p}_i|i⟩⟨i|\otimes U_i^{†}\Lambda \left(U_i{\rho }_{\psi }{U}_i^{†}\right)U_i\otimes {\rho }_i+\sum _{i\ne j}^d\sum _i^d\sqrt{p_i{p}_j}|i⟩⟨j|\otimes \dots ,$$

$$\text{tr}\left[\left(1\mathrm{l}\otimes A\otimes {1\mathrm{l}}^{\otimes d-1}\right){\rho }_f\right]=\text{tr}\left[A\sum _i^d{p}_i{U}_i^{†}\Lambda \left(U_i{\rho }_{\psi }{U}_i^{†}\right)U_i\right]=\text{tr}\left[A\overline{\Lambda }\left({\rho }_{\psi }\right)\right],$$

Full text

Keywords: quantum computing, quantum forking, quantum sampling, quantum measurement, quantum operating system

1 Introduction

Designing an efficient quantum algorithm to solve a computational task does not alone ensure a quantum advantage over a classical counterpart, but there must also be an efficient procedure to prepare the desired initial quantum state. Existing methods for preparing an arbitrary quantum state [1, 2, 3, 4, 5, 6, 7, 8, 9], a famous example being quantum random access memory (QRAM) [10, 11, 12, 13, 14], introduce resource overheads, even though the hardware and process complexities may scale efficiently with respect to the size of the data to be encoded. It is therefore imperative to minimize the number of state preparation routines. An input quantum superposition state cannot be reused for another task once measured due to the measurement postulate of quantum mechanics. Moreover, the quantum state cannot be cloned. Hence, in general, one is forced to generate an input state in every execution of a quantum algorithm. However, many quantum information processing (QIP) tasks rely on repeating the measurement for sampling the answer. Thus the true advantage of harnessing quantum mechanics for information processing becomes unclear when the aforementioned redundancy is imposed. As a means to circumvent this fundamental issue in certain applications, quantum forking (QF) was introduced in [14], motivated by forking in classical operating systems that creates a separate address space for a child process for multitasking [15]. In [14], the application was limited to estimating the inner product of quantum states.

In this work, we present quantum forking-based sampling (QFS) to accelerate various tasks that require adding the results from independent quantum trajectories as a convex combination. With this framework, the number of state preparation routines and measurements required for performing a weighted power summation of measurement outcomes sampled from an arbitrary number of independent quantum processes remains constant, though this is at the cost of introducing a control qudit, ancilla qubits in arbitrary states, and a series of controlled swap gates. Moreover, QFS can be used to efficiently measure an arbitrary observable since a convex combination of Hermitian operators is also Hermitian. This is particularly useful when directly measurable observables are limited by experimental constraints. The weighted power summation of quantities measured in multiple quantum processes is required in solving various problems in quantum science as we demonstrate with examples in implementing a convex combination of quantum channels, detecting entanglement, and characterizing quantum control. We realize a proof-of-principle experiment of a QFS on two quantum computers in the cloud, the IBM Q 5 Tenerife [16] and Rigetti 16Q Aspen-1 [17], demonstrating the feasibility of the technique with near-term quantum hardware. QFS is fundamentally intriguing as it shows that without violating the no-cloning theorem, a single quantum state with ancillary space suffices to accomplish tasks that would naively require many copies of the quantum state.

Furthermore, when large-scale quantum hardware becomes available, a quantum operating system that deploys efficient resource management and acts as an interface between qubits and quantum programs is of fundamental importance [18]. Along with QRAM, the quantum forking algorithm developed here has the potential to be used as a building block for such a quantum operating system.

The remainder of the paper is organized as follows. Section 2 reviews and further generalizes the quantum forking framework which was first introduced in [14]. Next, we describe the QFS protocol for an arbitrary weighted power summation of results from $d$ independent quantum trajectories using a constant number of state preparations and measurements in section 3.1 and section 3.2 for the expectation value measurement and the projective measurement, respectively. In section 4, we illustrate how the number of state preparations can be reduced in constructing a convex combination of quantum channels, which naturally enables the quantum channel twirling, detecting entanglement witnesses, and purity benchmarking as example applications for which QFS can be useful. Section 5 demonstrates the proof-of-principle implementation of a simple QFS experiment on the cloud quantum computers, and section 6 concludes.

2 Quantum forking

Quantum forking is a process that creates an entangled state to allow a target quantum state $|\psi\rangle$ to undergo $d$ independent evolutions in superposition [14]. At the end of the computation, some measurement procedure is employed to find the desired answer more efficiently compared to when the quantum state undergoes these evolutions one at a time. This can be achieved by coupling the target state $|\psi\rangle$ to a control qudit (or $\log_{2}(d)$ qubits) and $d-1$ ancilla qubits in some arbitrary state $|\phi_{j}\rangle$, such that the target state undergoes independent processes in $d$ orthogonal subspaces. The quantum circuit for realizing QF is depicted in figure 1.

The quantum forking is initiated by the series of controlled swap (c-swap) gates controlled by the state of the qudit. These gates evolve the total state as

[TABLE]

Hereinafter, the tensor product symbol is omitted for brevity when the meaning is clear. Equation (2) shows that QF creates an entangled state whereby the target quantum state $|\psi\rangle$ is encoded in a different qubit for each subspace referenced by the control qudit. Thus, by applying local unitaries, the target quantum state can undergo $d$ independent processes simultaneously. For instance, the total state after the application of local unitary operators becomes

[TABLE]

The ancilla qubits can be untouched if desired, by using controlled unitary operators.

3 Quantum forking for sampling

3.1 Expectation value measurement

Quantum forking can be furnished with a measurement procedure to evaluate a weighted power sum of the following form with only a constant number of initial state generations:

[TABLE]

where $p_{i}$ is a non-negative real number satisfying $\sum p_{i}=1$, $q$ is a positive integer, and $M_{i,j}$ is an observable. In general, estimating equation (3) to within $\epsilon$ with a probability of error $\delta$ requires $O(q^{\prime}d\log(1/\delta)/\epsilon^{2})$ state preparations [19], where $q^{\prime}\leq q$ is the number of unique observables in the non-linear sum. QFS yields the same result with $O(q\log(1/\delta)/\epsilon^{2})$ state preparations, reducing the time complexity by about a factor of $d$. In the following, we explain QFS for linear ($q=1$) and quadratic ($q=2$) sums using the cases where $M_{i,1}=M_{i,2}$ and $d=2$.

3.1.1 Linear summation

Adding two expectation value measurement outcomes with equal weights can be done with one control qubit and one ancilla qubit in an arbitrary state $|\phi\rangle$, as depicted in figure 2(a). First, the control qubit is prepared in the equal superposition state via the Hadamard gate (denoted H). The first c-swap gate then yields

[TABLE]

The two local unitaries transform the above state to

[TABLE]

Finally, another c-swap gate unforks, i.e., reverses the forking, such that the final state is

[TABLE]

Now the expectation value of an observable $M$ measured on the target qubit gives the desired average of the two quantities:

[TABLE]

where $M_{j}=U_{j}^{\dagger}MU_{j}$.

If one performs the local measurement on both target and ancilla qubits without unforking, i.e., directly on $|\Phi_{2}\rangle$, the measurement outcomes are $\langle\Phi_{2}|{\mathchoice{\rm 1\mskip-4.0mul}{\rm 1\mskip-4.0mul}{\rm\mskip-4.5mul}{\rm 1\mskip-5.0mul}}\otimes M\otimes{\mathchoice{\rm 1\mskip-4.0mul}{\rm 1\mskip-4.0mul}{\rm\mskip-4.5mul}{\rm 1\mskip-5.0mul}}|\Phi_{2}\rangle=(\langle\psi|M_{1}|\psi\rangle+\langle\phi|M_{1}|\phi\rangle)/2$ and $\langle\Phi_{2}|{\mathchoice{\rm 1\mskip-4.0mul}{\rm 1\mskip-4.0mul}{\rm\mskip-4.5mul}{\rm 1\mskip-5.0mul}}\otimes{\mathchoice{\rm 1\mskip-4.0mul}{\rm 1\mskip-4.0mul}{\rm\mskip-4.5mul}{\rm 1\mskip-5.0mul}}\otimes M|\Phi_{2}\rangle=(\langle\psi|M_{2}|\psi\rangle+\langle\phi|M_{2}|\phi\rangle)/2.$ Thus if $\langle\phi|M_{j}|\phi\rangle$ is known, the linear sum shown in equation (3.1.1) can be calculated without the reversal c-swap gate at the cost of performing the local measurement on the ancilla qubit as well. We narrow our discussion to the general case without such a priori information, and focus on the quantum forking with the unforking step.

There are several interesting remarks. First, the ancilla state $|\phi\rangle$ can be arbitrary and even unknown. As a result, one can use any state that is the easiest to prepare in the given experimental setup, such as a thermal equilibrium state or a leftover state from the previous algorithm. We assume that the computational cost of preparing such states is negligible compared to the cost of $|\psi\rangle$ preparation. Second, the same outcome can be obtained when the control qubit is initially prepared in $|1\rangle$, since this only alters the sign of the second term in equation (4). Thus the maximally mixed state can be used as the initial state of the control qubit. This state is more difficult to prepare, but we assume that the cost is still negligible compared to that of the preparation of $|\psi\rangle$. Third, the weights $p_{i}$ can be manipulated by initializing the control state to either a mixed state $\sum_{i}p_{i}|i\rangle\langle i|$, or a pure state $\sum_{i}\sqrt{p_{i}}|i\rangle$. Finally, the unitary operators can be replaced with any quantum channel. The last two remarks are supported by the following. Let the initial state be represented as a density matrix $\rho_{i}=(p_{1}|0\rangle\langle 0|+p_{2}|1\rangle\langle 1|)\otimes\rho_{\psi}\otimes\rho_{\phi}$. The full QFS protocol produces the final density matrix $\rho_{f}=p_{1}|0\rangle\langle 0|\otimes\Lambda_{1}(\rho_{\psi})\otimes\Lambda_{2}(\rho_{\phi})+p_{2}|1\rangle\langle 1|\otimes\Lambda_{2}(\rho_{\psi})\otimes\Lambda_{1}(\rho_{\phi})$, where $\Lambda_{i}$ is a completely positive trace preserving (CPTP) map. Then the expectation value measurement gives

[TABLE]

Since off-diagonal terms in the density matrix of the control qubit vanish in the expectation value, equation (3.1.1) also holds for a control qubit initialized in a pure state with probability amplitudes whose absolute squares correspond to the weights.

3.1.2 Quadratic summation

To evaluate the squared sum of expectation values with QFS, two qubits prepared in $|\psi\rangle$ and two arbitrary ancillae are needed. A series of c-swap gates initiates QF, and each pair of the qubits experiences the independent unitary evolutions denoted by $U_{1}$ and $U_{2}$, respectively. After additional c-swap gates unfork, the final state is given as

[TABLE]

Now measuring $\langle M\otimes M\rangle$ on the target qubits gives

[TABLE]

The procedure is shown in figure 2(b). By the same argument used above, the maximally mixed state can be used as the initial state of the control qubit, and any local CPTP map can be used instead of the local unitaries. Moreover, the control qubit can be replaced with a mixed state $\sum_{i}p_{i}|i\rangle\langle i|$, or a pure state $\sum_{i}\sqrt{p_{i}}|i\rangle$ in order to assign unequal weights. Note that more general non-linear sums, such as $\sum_{i}^{d}p_{i}\langle M_{i}\rangle\langle N_{i}\rangle$, can also be evaluated by measuring $\langle M\otimes N\rangle$.

3.1.3 General summation

In general, a density matrix in the following form can be used as an input to QFS circuit for evaluating equation (3),

[TABLE]

where $\rho_{\phi}$ is a density matrix for $q(d-1)$ arbitrary ancilla qubits. At the end of a QFS circuit, the final density matrix is given as

[TABLE]

where $\rho_{j}$ is the density matrix for the ancilla qubits that does not contribute to the measurement result of the target qubit. Measuring the expectation value of a $q$-local observable $\bigotimes_{j}^{q}M_{j}$ yields the weighted power sum in equation (3).

3.2 Projective measurement

A QFS circuit can also be followed by the projective measurement on the target qubit with an operator $\Pi_{m}$, which projects the target state onto the $m$th subspace with the probability $\text{Pr}(m|\rho_{f})=\text{tr}\left(\Pi_{m}\rho_{f}\right)$. Thus if $q$ copies of a target qubit undergoes independent quantum channels and are measured with a $q$-local projector, $\bigotimes_{j}^{q}\Pi_{j,m}$, the probability to measure the target qubit state in the $m$th subspace is

[TABLE]

Therefore, the projective measurement on the target qubit yields the weighted power sum of the probabilities of an outcome, which would be obtained in a series of independent quantum measurements, without performing each measurement individually.

3.3 Discussion

A general QFS for evaluating equation (3) requires $O(\log(1/\delta)/\epsilon^{2})$ experiments with $q$ target qubits, 1 control qudit of dimension $d$, $q(d-1)$ ancilla qubits in any arbitrary (even unknown) states, and $2q(d-1)$ c-swap gates. The control qudit can be in the mixed state where an $i$th diagonal element of the density matrix dictates the weight $p_{i}$. For uniform weights, i.e., $p_{i}=1/d\;\forall\;i$, the control qudit can be in the maximally mixed state. The advantage of QFS becomes apparent when $d$ is large and the preparation of the initial target state $|\psi\rangle$ is complex. The temporal cost of repeating the individual quantum circuits is traded for the spatial cost of having the ancilla qubits in QF. But these ancilla qubits can be in any arbitrary state, and hence the cost of preparing them is negligible. In fact, the same ancilla qubit can be repeatedly used for multiple QFS tasks without having to be reinitialized. Another notable aspect is that the dephasing noise on the control qubit does not alter the result since only the diagonal terms in the density matrix of the control qubit contribute to the measurement outcome, and the c-swap does not propagate phase errors from the control qubit. On the other hand, QFS may be impractical for large $q$ when the $q$-local measurement is experimentally challenging to perform.

4 Applications

QFS for linear and quadratic summations can be applied to speedup various tasks in quantum science as we demonstrate with the following examples.

4.1 Convex combination of quantum channels

When the CPTP map $\Lambda_{i}$ is a unitary operator, performing the linear summation ($q=1$) using QFS naturally implements a mixed unitary channel $\Phi$, which is a convex combination of unitary channels, i.e., $\Phi(\rho)=\sum_{i}^{d}p_{i}U_{i}\rho U_{i}^{\dagger}$. This can be seen in the following equation.

[TABLE]

where $A$ is a Hermitian operator and $\rho_{f}$ is given in equation (12) for $q=1$. Since $A$ can be any measurement operator, the expectation value measurement or the projective measurement preceded by a mixed unitary channel for an arbitrary number of unitary operators can be carried out using only a constant number of state preparations and measurements.

The QFS procedure to construct a convex combination of unitary channels can naturally extend to quantum channel twirling. Twirling has been established as an important technique in quantum information science that appears in a variety of contexts, such as entanglement purification [20, 21], characterizing quantum processes [22, 23, 24, 25, 26, 27], studying the performance of quantum error correcting codes [28, 29, 30], and quantum error mitigation [31, 32]. Twirling a quantum channel $\Lambda$ with a finite set of unitaries, $\mathcal{U}=\{U_{1},\ldots,U_{d}\}$, gives the averaged channel as

[TABLE]

The quantum circuit for twirling a quantum channel $\Lambda$ with a single state preparation via quantum forking is depicted in figure 3.

The target qubit initially given as $\rho_{\psi}$ and $d-1$ arbitrary ancilla qubits experience an identical quantum map $\Lambda$ in between forking and unforking steps, and the map in each qubit is conjugated by the elements of $\mathcal{U}$. The final density matrix of the QFS protocol can be written as

[TABLE]

where $\rho_{i}$ represents the ancilla qubits that are irrelevant to the final result of our interest. The measurement on the target qubit yields

[TABLE]

where $A$ can be any measurement operator.

4.2 Entanglemet Witness

The linear summation can be utilized in the experimental measurement of entanglement witnesses (EW). This also serves as an example in which QFS is useful for measuring an arbitrary observable. An EW is an observable that distinguishes an entangled state from separable ones, and is generally a useful tool in quantum information science for studying entanglement without relying on expensive quantum state tomography [33]. More formally, the expectation measurement of an entanglement witness $W$ gives $\text{tr}(W\rho_{sep})\geq 0$ for all separable state $\rho_{sep}$, while there exists an entangled state $\rho_{ent}$ such that $\text{tr}(W\rho_{ent})<0$. An EW can also be viewed as a hyperplane separating some entangled states from the set of separable states [34]. Since $W$ is a Hermitian operator, it can be written as a convex combination of other Hermitian operators, i.e., $W=\sum_{i}c_{i}A_{i},\;A_{i}=A_{i}^{\dagger}\;\forall i,$ and $\;c_{i}\in\mathbb{R}\;\forall i$. Thus, an EW can be constructed by measuring the expectation values of experimentally available observables $A_{i}$, and post-processing the measurement outcomes with appropriate weights. With this, the benefit of QFS becomes apparent. Instead of measuring the observables needed to construct the linear sum individually, QFS produces the same result by measuring the expectation value of a single observable, i.e., the one that is the easiest to measure in the laboratory, such as $\sigma_{z}$. To elucidate such a QFS application, we can consider an EW which determines whether a given state is useful for performing quantum teleportation via QFS. The teleportation witness operator can be written as $W_{t}=\left({\mathchoice{\rm 1\mskip-4.0mul}{\rm 1\mskip-4.0mul}{\rm\mskip-4.5mul}{\rm 1\mskip-5.0mul}}\otimes{\mathchoice{\rm 1\mskip-4.0mul}{\rm 1\mskip-4.0mul}{\rm\mskip-4.5mul}{\rm 1\mskip-5.0mul}}-\sigma_{x}\otimes\sigma_{x}+\sigma_{y}\otimes\sigma_{y}-\sigma_{z}\otimes\sigma_{z}\right)/4$ in terms of Pauli operators [35]. A naive witness experiment requires measuring three two-qubit Pauli observables. Alternatively, the same quantity can be evaluated with the QFS circuit shown in figure 4. Since there are three independent observables to be measured, i.e., $d=3$, a qutrit is needed to create three forking trajectories. Without loss of generality, the ancilla qubits are all in the same state $|\phi\rangle$ in the figure, but they can be in any state without altering the final outcome. Using $H\sigma_{z}H=\sigma_{x}$, $S\sigma_{x}S^{\dagger}=-S^{\dagger}\sigma_{x}S=\sigma_{y}$, where $S$ denotes the phase gate, it is straightforward to verify that the measurement of $\langle\sigma_{z}\otimes\sigma_{z}\rangle$ on the target two-qubit state yields $\langle\sigma_{x}\otimes\sigma_{x}-\sigma_{y}\otimes\sigma_{y}+\sigma_{z}\otimes\sigma_{z}\rangle$. From this, $W_{t}$ can be obtained. Therefore, the use of QFS reduces the number of Pauli observables to be measured from three to one.

In practice, qutrits may not be available in a given experimental setup, and it could be easier to prepare qubits. In the next example, we explain how to create three independent processes with equal weights using two qubits.

4.3 Purity benchmarking for quantum control

Measuring the incoherent error rate of a quantum channel has significant implications in the development of quantum devices. The incoherent error can be quantified using purity benchmarking [36, 37]. Purity benchmarking can be combined with the standard randomized benchmarking protocol to distinguish coherent and incoherent error, which is an important step to understand different types of noise affecting quantum control. The purity benchmarking protocol requires the estimation of the purity $P=\sum_{j=1}^{4^{n}-1}\langle\mathcal{P}_{j}\rangle^{2},$ of a state of $n$ qubits, where $\mathcal{P}_{j}\in\{{\mathchoice{\rm 1\mskip-4.0mul}{\rm 1\mskip-4.0mul}{\rm\mskip-4.5mul}{\rm 1\mskip-5.0mul}},\sigma_{x},\sigma_{y},\sigma_{z}\}^{\otimes n}\setminus{\mathchoice{\rm 1\mskip-4.0mul}{\rm 1\mskip-4.0mul}{\rm\mskip-4.5mul}{\rm 1\mskip-5.0mul}}^{\otimes n}$ denotes an element in the set of $n$-qubit Pauli operators minus the identity matrix. Thus, the number of expectation values to be evaluated increases exponentially with the number of qubits. This is an example where $d$ grows large very quickly, and $q$ is small. Hence, this problem is well suited for QFS. The single qubit purity benchmarking requires the quadratic summation ($q=2$). Hence there must be two target qubits provided at the beginning of the QFS protocol, and the ability to measure two-local observables. In particular, we again assume that $\langle\sigma_{z}\otimes\sigma_{z}\rangle$ is straightforward to evaluate. Furthermore, since one needs to measure three observables, $\sigma_{i}$, $i\in\{x,y,z\}$, with equal weights, one control qutrit in the completely mixed state and four arbitrary ancillae can be used.

In the absence of qutrits, one can use two qubits such that only three different trajectories are superposed with appropriate weights. One way to achieve this is to prepare the control qubits in $H\otimes R_{y}(\theta)|00\rangle=(|00\rangle+|10\rangle)/\sqrt{3}+(|01\rangle+|11\rangle)/\sqrt{6}$, where $R_{y}(\theta)$ is the rotation around $y$-axis and $\theta=2\arccos{\sqrt{2/3}}$. Then three independent forkings can occur with the control states $|00\rangle$, $|10\rangle$, and $(|01\rangle+|11\rangle)/\sqrt{2}$, allowing the given trajectories to be measured with equal probabilities as desired. The QFS circuit for the single qubit purity measurement is depicted in figure 5. As before, the ancilla qubits are all in the same state $|\phi\rangle$, but any state can be used without altering the final outcome.

The target qubits and the ancillae first undergo the same single-qubit quantum channel $\Lambda$. But just before unforking, either $H$ or $HS^{\dagger}$ are applied to measure $H\sigma_{z}H=\sigma_{x}$ or $SH\sigma_{z}HS^{\dagger}=\sigma_{y}$, as desired in the purity measurement.

5 Experiment

We present the experimental results from a proof-of-principle implementation of QFS using the IBM Q 5 Tenerife [16] and Rigetti 16Q Aspen-1 [17] quantum processors. Suppose a single qubit is prepared by rotating $|0\rangle$ around an unknown axis, either x, y or z, of the Bloch sphere by a known angle $\theta$. After the state preparation, by measuring at least two Pauli observables, the axis of rotation can be discriminated. Alternatively, the sum of any two Pauli expectation values can be used. For example, $\langle\sigma_{z}\rangle+\langle\sigma_{x}\rangle$ results in $\cos(\theta)$, $\cos(\theta)+\sin(\theta)$ or $1$ for the rotation along x, y or z axis, respectively. Thus by measuring $\langle\sigma_{z}\rangle+\langle\sigma_{x}\rangle$ with respect to $\theta$ reveals the rotating axis. A simple three-qubit QFS with one Pauli expectation measurement can evaluate the same quantity. The QFS circuit implemented with IBM and Rigetti cloud quantum computers is shown in figure 6(a). After creating two forking paths via the first c-swap gate, a Hadamard operation is applied to the ancilla qubit for the $\langle\sigma_{x}\rangle$ measurement. Then the final c-swap gate is applied to unfork, and $\langle\sigma_{z}\rangle$ measurement on the target qubit yields the desired outcome.

Theoretical calculations and experimental data obtained using the IBM and Rigetti quantum processors are compared in figure 6(b), (c) and (d). The square, circle and diamond symbols represent the expectation value of $\sigma_{z}$ when the rotation of an angle $\theta$ is applied along the $x$, $y$ and $z$ axis, respectively. For each axis, three sets of experiments are performed with a different direction of changing $\theta$, that is varied from 0 to $2\pi$ in increments of $\pi/8$, and the results are averaged in order to suppress experimental bias in the direction of $\theta$ that may arise due to drift in calibration. In the first and second sets, $\theta$ is uniformly increased and uniformly decreased, respectively. In the last set, $\theta$ is randomly selected between 0 and $2\pi$ in $\pi/8$ increments. Each experiment is repeated for 8192 runs to collect measurement statistics. Thus each data shown in figure 6(c) and (d) is an average of 24576 runs. Despite experimental deviations from theory as illustrated with the amplitudes errors of the curves, the QFS protocol manifests successful discrimination of the initially unknown axis of the rotation with only a single expectation value measurement using currently available cloud quantum computers.

6 Conclusion

We developed quantum forking-based sampling as a tool to avoid redundant initial state preparations and significantly reduce the time complexity of weighted power summation, which has wide applications in quantum science. Quantum forking creates an entangled state that stores the quantum information in a different qubit in each subspace. Each subspace undergoes independent quantum trajectories in superposition. Then quantum interference enables an arbitrary weighted power summation of all outcomes from these quantum trajectories instantly in one measurement. With this technique, the $q$th power summation of $d$ measurement outcomes with arbitrary weights can be carried out with the constant cost of initial state preparation, while requiring $q(d-1)$ ancilla qubits given in arbitrary states, a control qudit with dimension $d$, $q$-local measurement and $2q(d-1)$ c-swap gates. The number of state preparation routines is reduced by $O(d)$. Hence QFS is particularly useful when $d$ is large, the state preparation procedure is complex, and $q$ is small. As examples, we showed how QFS can be utilized to reduce the number of state preparations and measurements in the implementation of mixed unitary channels, twirling quantum channels, entanglement witnesses and benchmarking incoherence of noise in quantum control. The proof-of-principle is demonstrated using the cloud quantum computers from IBM and Rigetti. Our results show that for a particular family of problems, a single quantum state entangled to an arbitrary ancillary space can be exploited to provide the result as if multiple quantum states are available without violating the no-cloning theorem, paving the way for further research. In future work, we plan to apply QFS for quantum Monte Carlo simulations, such as those used for quantum master equation unravelling, where the solutions of the quantum master equation can be obtained as an ensemble average of the solutions to the stochastic Schrödinger equation [38]. Finding other schemes with which the quantum forking can reduce the number of state preparations, even by a constant amount, also remains an interesting open problem.

We acknowledge use of IBM Q and Rigetti Quantum Cloud Services for this work. The views expressed are those of the authors and do not reflect the official policy or position of IBM or the IBM Q team. The use of Rigetti hardware was made possible through the Developer Partnership between Rigetti and ProteinQure. We thank the Rigetti team for help associated with the Quantum Cloud Services. This work was supported in parts by the Ministry of Science and ICT, Korea, under an ITRC Program, IITP-2018-2018-0-01402, and an NRF Program, 2018K1A3A1A09078001, and by the South African Research Chair Initiative of the Department of Science and Technology and the National Research Foundation. We thank Dr. Graeme Pleasance for proofreading the manuscript.