Module for arbitrary controlled rotation in gate-based quantum algorithms

The problem of linear system can be written as

where $A\in R^{N\times N}$, $x,b\in R^{N},N=2^{n}.$ $A$ can be represented by an $N\times N$ Hermitian matrix with a spectral decomposition of $A=\lambda_{j}\ket{u_{j}}\bra{u_{j}}$, where $\lambda_{j}$ is the $j$th eigenvalue of matrix $A$ with the corresponding eigenvector $\ket{u_{j}}$. For convenience, we can assume that $b$ and $x$ are normalized and map them to the quantum states $\ket{b}$ and $\ket{x}$ respectively. The overview of the quantum circuit for HHL algorithm is presented in Fig. 2 and a simple description is listed as follows. Note that we have assumed that all computations have been exact. The initial state of $Reg.E$ and $Reg.B$ is

(i) Apply phase estimation with

where we can assume without loss of generality that the evolution time $t=2\pi$. The registers become the state

where $\tilde{\lambda}_{j}$ is an approximation of $\lambda_{j}$.

(ii) Add an ancilla qubit and perform the operation in Eq. (2), we have

(iii) Apply the inverse of all operations before $R_{y}$. If the eigenvalues are perfectly estimated, the result would be

(iv) Perform the measurement on the ancilla qubit, if the ancilla qubit is in the state $\ket{1}$, then the register $B$ becomes the state

where $\left|{x^{{}^{\prime}}}\right\rangle$ is an approximation of $\left|x\right\rangle$. The steps (ii) can be seen as the procedure of controlled rotation implemented by the method in Sec. II. The elements of diagonal operator $D_{f}$ are $e^{{2\pi\boldsymbol{i}}\theta_{j}}$, with $\theta_{j}=\frac{1}{2}\arcsin\left({C{\lambda_{j}^{-1}}}\right)$.

The HHL algorithm is of great inspiration to the design of quantum machine learning (QML) algorithms. The algorthms that utilize HHL algorithm as a subroutine or inspired by HHL algorithm can be defined as HHL-based QML algorithms. By changing the value of $\theta$ in the diagonal element $e^{{2\pi\boldsymbol{i}}\theta}$ of the unitary diagonal matrix, our proposed controlled rotation can be applied to the following HHL-based QML algorithms.

The encoding of the classical data can be maily categorized into two types: analog encoding (or called amplitude encoding), which encodes data into amplitudes of a state, and digital encoding (or called basis encoding), where the data are stored as qubit strings. The former is the basic condition for quantum acceleration, whereas the latter is required to perform arithmetics on quantum devices. Ref. Mitarai et al. (2019) has proposed algorithms that convert these two encodings to one another, where the proposed algorithms are seriously based on the fact that the transformation

can be performed effectively. However, Ref. Mitarai et al. (2019) still omits the details of Eq. (17), which is a small but not negligible part of their proposed algorithms. The method in Sec. II can just complement this technical detail without considering the complexity. Thus the controlled rotation module can also be applied in arbitrary nonlinear transformations of amplitudes of a quantum state, data loading and quantum state preparation Mitarai et al. (2019).

Moreover, Eq. (17) has been used as an important part in implementing quantum neurons to merge the nonlinear, dissipative dynamics of neural computing into the linear, unitary quantum system Schuld et al. (2015); de Paula Neto et al. (2020); Yan et al. (2020). The diagonal matrix has stored a set of weights, inner products or activation function values in its diagonal elements.

Taking the HHL algorithm as an example, we will illustrate that the controlled rotation will not influence the acceleration of the quantum algorithm. Based on phase estimation and amplitude amplification, the details of the complexity and error analysis of HHL algorithm have been shown in Ref. Harrow et al. (2009). $e^{iAt}$ can be simulated in time $O($ log $(N)d^{2}t)$ Berry et al. (2007), where $d$ is the sparseness of $A$. If the phase estimation involving $e^{iAt}$ errs by $O(1/t)$, which translates into a relative error of $O(1/\lambda t)$ in $\lambda^{-1}$. The HHL algorithm has considered the complexity of the controlled rotation without a specific implementation. If $\lambda\geq 1/\kappa$ taking $t=O(\kappa/\varepsilon)$ induces a final error of $\varepsilon$. Considering all of these above, the running time of HHL algorithm turns to $O({{\log\left(N\right){d^{2}}{\kappa^{2}}}\mathord{\left/{\vphantom{{\log\left(N\right){d^{2}}{\kappa^{2}}}\varepsilon}}\right.\kern-1.2pt}\varepsilon})$, which offers an exponential speedup over the fastest classical algorithm: the conjugate gradient method. The conjugate gradient method runs in $O(N\kappa)$ (or $O(N{\sqrt{\kappa}})$ for positive semidefinite matrices). Typically, the condition number $\kappa$ is taken as $O({1\mathord{\left/{\vphantom{1\varepsilon}}\right.\kern-1.2pt}\varepsilon})$, where $\varepsilon={2^{-m}}$. In this case, the running time of HHL algorithm increases exponentially with the parameter $m$, which is one of four caveats for HHL proposed in Ref. Aaronson (2015). These caveats can be crucial in practice. Thus the speed-up of HHL algorithm must be based on that both $\kappa$ and ${1\mathord{\left/{\vphantom{1\varepsilon}}\right.\kern-1.2pt}\varepsilon}$ are poly $\log\left(N\right)$.

In a similar way, even if the running time of the controlled rotation is $O(2^{m})$, it would be translated into $O(poly({1\mathord{\left/{\vphantom{1\varepsilon}}\right.\kern-1.2pt}\varepsilon}))$. The controlled rotation would not influence the acceleration of original algorithms theoretically.

In this section, we analyze the space (circuit width or the qubit complexity) and time (circuit depth or the gate complexity) resources required for different methods of the controlled rotation module. As any unitary operation can be decomposed into elementary gates Barenco et al. (1995), the elementary gate library is universal. We assume that any single- and two-qubit gate can be seen as elementary gates. To analyze the gate complexity, we use elementary gate complexity. While talking about the actual value, we use elementary gates and Toffoli gates. In the previous works, the common used methods that can construct any controlled rotation are mainly divided into two types: polynomial-fitting function method and measurement-based method. Table. 1 shows the comparisons of these different methods.

The polynomial-fitting function method includes Newton iteration,Taylor series, quantum function value binary expansion (QFBE) method, and so on. The basic principle of the polynomial-fitting function method is to transform the function calculation into quantum version of multiplication and addition, which has been studied in Refs. Saeedi and Markov (2013); Vedral et al. (1996); Beckman et al. (1996); Chuang and Modha (2000); Draper (2000); Cuccaro et al. (2004); Takahashi and Kunihiro (2005); Draper et al. (2006); Álvarez-Sánchez et al. (2008); Takahashi et al. (2010); Rieffel and Polak (2011). Reversibility of any unitary operation effects that addition and multiplication cannot be directly deduced from their classical Boolean counterparts. Ref. Vedral et al. (1996) first showed that the original addition of two registers $\ket{a}$ and $\ket{b}$ can be written as $\left|{a,b,0}\right\rangle\mapsto\left|{a,b,a+b}\right\rangle$ or $\left|{a,b}\right\rangle\mapsto\left|{a,a+b}\right\rangle$. If both $a$ and $b$ are encoded on $m$ qubits, implementing an adder costs $3m+1$ qubits, $20m+2$ CNOT gates and $20m-10$ Toffoli gates. Based on adder, multiplier is computationally more expensive, where a multiplier of $a$ with $b$ can be thought of as adding $a$ to itself $b$ times. In this way, multiplier takes more qubits and quantum gates to complete the multiplicative task. Thus the polynomial-fitting function method is not a resource-saving method at some times. Recently, Ref. Wang et al. (2020) develops the QFBE method to evaluate the transcendental functions in a recursive way. Totally, the QFBE method uses $34{m^{3}}-16{m^{2}}+4m$ quantum gates to implement the controlled rotaion.

The measurement-based method can be divided into two types: one is the RUS arithmetic (or function synthesis) Wiebe and Roetteler (2016) and the other is classical computing Lee et al. (2019). Focused on optimizing space, RUS arithmetic encodes numbers in the amplitudes of a qubit, or more properly as polar angles on the Bloch sphere. The core idea is utilizing measurement to implement nonlinear mappings between sets of input and output rotation angles. However, RUS arithmetic has not discussed an important problem that how many repetitions of these circuits are needed before a successful result is observed with high probability. Classical computing directly analyzes measurement outcomes from $\ket{\lambda}$ by means of classical computers. Based on the analyzed data, a simpler circuit implementation of the original part can be built together with reducing the circuit depth and space. Similarly, classical computing does not solve the problem of the number of measurements. The measurement-based method generally requires polynomial time and space complexity.

The idea of our method in Sec. II is fully combining the function outputs and quantum circuit design. Containing $2^{m}$ parameters, the accurate evaluation of diagonal unitary operations might be the most resourceintensive element. For space optimizing, we need to use the decomposition method to realize the diagonal operation $D$. Alternating controlled not gates and $R_{z}$ rotations, the best-known compiling algorithm provided circuits of size $2^{m}-3$ for arbitrary $m$-qubit diagonal unitaries Bullock and Markov (2004). As the result of the power exponent of the diagonal matrix is also diagonal, $2^{m}-3$ Toffoli gates and controlled-$R_{z}$ gates are also enough for implementing controlled $D^{2^{i}}$ gates. An efficient implementation of the phase estimation includes $O(m^{2})$ elementary gates for an inverse quantum Fourier transform and one call to controlled $D^{2^{i}}$. That is it totally needs $m\left({{2^{m+1}}-3}\right)+m\left({m+1}\right)/2+m$ single- and two-qubit gates and Toffoli gates.

Fig. 3(d) shows the total number of quantum gates that are needed to implement the controlled rotation in HHL algorithm with two different methods. When $m$ is less than 11, the number of quantum gates required by our method is less than QFBE. At this time, the HHL algorithm using our method can already make the fidelity of inversing the matrices with $\kappa\leq 1000$ close to 1, where the condition number 1000 already contains most of the matrices that need to be inverted in practice. Thus, our method only requires the least ancillas or the least quantum gates to maintain the high fidelity of quantum algorithms.

We define the diagonal unitary operator as

where $\theta_{i}\in(0,1]$ and $i\in\{0,1,\cdots,2^{m}-1\}$. Supposing the values of all $\theta_{i}$ are known in order, then the controlled-$D$ is written as

That is the $CD$ can be implemented with $2^{m}$ different $C^{m}R_{z}$ gates, where a $C^{m}R_{z}$ gate can be simulated by $O(m)$ gates with one auxiliary qubit Barenco et al. (1995). If the number of different $\theta_{i}$ is $O(poly(m))$, the gate complexity would be $O(poly(m))$. In this way, our method would be more competitive.

Quantum oracle, or called black box, is an important tool used in quantum computation. Many quantum algorithms would like to use the oracle as a part of themselves, such as phase flip of target state in Grover’s algorithm, modular exponentiation in Shor’s algorithm and contrlled rotation in HHL algorithm. The focuses of designing a quantum algorithm are complexity and error analysis. Most papers deal with a quantum algorithm but omit the details of implementation. Each oracle is implemented by a quantum algorithm itself. When an oracle is used to implemente an algorithm, it often significantly contributes to the depth and width of the corresponding algorithm: the depth of an algorithm is the number of gates to be performed sequentially, and its width is the number of qubits it actually manipulates. Although oracles are usually considered effective, they may affect the efficiency of implementing the algorithm within limited conditions. To evaluate whether a gate-based algorithm can be implemented and executed on a particular NISQ device, we have to carefully consider the exact value and complexity of the width and depth of a circuit.

Ref. Leymann and Barzen (2020) has discussed different impact factors of algorithm implementations and drawn a conclusion: a quantum algorithm using oracles (i.e. black box functions in general) must be modified by expanding these functions as quantum circuits themselves and substituting these functions by the corresponding circuits. For modular gate-based algorithms, each module will affect the implementation of the entire algorithm. Existing generic constructions focus on the complexity of the circuit depth rather than actual value. In theory, the polynomial algorithm is better than the exponential algorithm. However, time cost of the exponential algorithm in a certain range will be less, when the factor of the polynomial is large. The result in Fig. 3(d) validates our point.

Although our method allows to reduce the quantum resources in some way, the resulting circuits are still quite expensive, especially in terms of the number of required quantum gates. At present, there is no satisfactory method to realize arbitrary controlled rotation, then the acceleration of some quantum algorithm may be inhibited.