Data Science and Machine Learning

Formally, Data science is an inter-disciplinary field that uses scientific methods, processes, algorithms and systems to extract knowledge and insights from many structural and unstructured dataWikipedia/Data_science. The core object of research in this field is data for the goal of knowledge. This approach is different from research of theoretical study like geometry by deductive reasoning. A nice example is Kepler’s Law, here we list two approaches to it in the following to show the difference between two paradigm.

1. Kepler type
   • Analyze the data from Tycho
   • Summarize the pattern of data in simple way(the first and second law, Occam’s razor)
   • Fit the data and generalize the quantitative rule(the third law)
2. Newton type(also used in the modern textbook)
   • Admit some axioms of the system(Newton’s law)
   • With mathematical approach write the equation and solve it
   • Discuss the properties of the solution

We call the Kepler type data-driven, and this paradigm is the core of data science.

Roughly speaking, there are three parts for data science: data collection, data storage, and learn from data. Though the other two are also important, our main goal here is the last one. The algorithm for this purpose is Machine Learning. Most machine learning tasks can be classified into the following three frameworks.

1. Supervised learning

   • Data: a set of input $x$ ) , and its label $y$ )) ${x_i,y_i}_{i=1}^N$
   • Goal: find a model for the map from $x$ ) , to $y$ )) of $y=f(x;\theta )$

   There are two main applications to supervised learning: regression (continuous $y$ )) ) and classification (discretized $y$ )) )

2. Unsupervised learning

   • Data: a set of input $x$ ) , , without labels. $\{x_i{\}}_{i=1}^N$
   • Goal: find the hidden patterns or grouping data.

   Dimensionality reduction, clustering, generative modeling.

3. Reinforcement learning

   • Data: delayed feedback signal(reward) after action. Like the win/lose in a chess game
   • Goal: learning an optimal policy(i.e. how to act). Like learn how to play a chess game

Though we list these classes of machine learning, the modern development are not distinct in this level. To solve the complex problems in the real-world we need the cooperation of different technologies for their own parts. To classify such the mixed projects are difficult and meaningless. As a popular and growing technology, there will be many new contents enter the field of machine learning. Just open your mind and be prepared.

Quantum Tech to Data Science

Quantum technology has been one of the most important concepts in the world now. Some people call the control and application of the quantum systems the Second Quantum Revolution, to distinguish against the establishment of quantum mechanics in the early 20th century. To data science, the impact of quantum tech is well described by the following figure from wiki/Quantum-machine-learning.

As quantum tech comes into our sight, a new type of data now is needed to be considering. Classical data is encoded by classical physical systems and its values are deterministic at each stage of processing. The information we touch in the daily life are all classical data, like this report, logical variables by whether voltage in the wire of computer is greater than a threshold or not, and much other analog data. Quantum data is encoded by quantum systems. Like the entities in the Hilbert space(the state of qubit), such data is quiet different from the classical one especially in the read/write rule. By the high representability of digits, we can still simulate the quantum data on classical computer. But since the dimension of Hilbert space (amounts of quantum variables) are exponential to the number of classical variables, this approach is incapably expensive.

Another aspect of the figure above is the type of algorithm. It is not only means the software we handle the data, but also the hardware we used to implement the program. This part contains the storage and processing. The former is qubits and quantum gates, which has been proved to be universal to simulate any quantum system and their evolution, just like the classical bits and classical gates. However, the quantum nature of qubits makes it possible to handle quantum data with polynomial scaling cost(if we can prepare and hold the qubits as easy as we do for classical bits in the sense of scaling). The latter concept (processing), i.e. algorithm or software, is the analog of the classical algorithm and programs running on the classical computer. There are two paradigms for quantum algorithm, one can be represented as the combination of a set of quantum gates, while the other way is based on the adiabatic theorem (wiki/Adiabatic-quantum-computation). These two approaches has been proved to be equivalent (D.Aharonov 2005, H.Yu 2018).

Quantum Speedup for Classical Machine Learning

Quantum computing has been proven significantly more powerful than classical machine on certain problems. In the past decades, the theory about hardware (architecture) of quantum processor and software (algorithm) on quantum computer have been rapidly developed. Though currently, there are still experimental issues as barriers between us and large scale quantum computer, the theoretical preparation for applying quantum technology on machine learning has been sort of made. In this section, we focus on the quantum speedup for classical machine learning, i.e., the outperformance of quantum algorithm in the field of classical machine learning.

Essential Techs for Applied Quantum Computing

There are two essential technologies required in quantum machine learning. One is the quantum Random Accessible Memory, which is usually mentioned as the hardware, and the other is the quantum linear algebra algorithms in software level. The former might be suspected to be essential, since there are actually many quantum machine learning algorithms being free from qRAM. Recently, some new approaches have been studied for handling classical data in a quantum machine like quantum embedding (S. Lloyd 2020) and quantum feature map (V. Havlicek 2018). However, as a generic data loader for quantum machine learning on classical data, it is still valuable to discuss it mathematically here.

Data Loader: qRAM

The Random-Access Memory(RAM) on classical computers provides essentially a tree structure for addressing. Such addressing with conventionally implementation would cost exponentially large energy.

Conventional Classical RAM architecture

Basically, a classical RAM is composed of a memory array of size $N$ serving $N$ bits to read and write, an input register(addressing register) and an output register. A normal memory call can be described as (R. C. Jaeger, “Microelectronic Circuit Design”)

1. An $n$ - ---bit string is read into input register. These $n\sim \log N$ bits store the address of the memory cell to be called, as the path along the tree. For bifurcation case, it is a series of $\{0,1\}$ with $n={\log }_{2}N$ ,, and at $k$ ,-----th level of the tree, the $0,1$ value at $k$ ,-----th bit denotes the left and right edge.
2. Along the addressing path, the output register stores the content of memory cell, or a write circuit would modify its value for the write operation.

Within this procedure, the first addressing bit should control one gate at that node. However, the $k$ ,-----th bit must control all $2^{k-1}$ gates at the $k$ ,-----th level of the tree for all possible paths. Like:

from the paper (V. Giovannetti 2008).

Thus, though classical RAM serves the $\mathcal{O}(1)$ time complexity (or $\mathcal{O}(\log N)$ for generic random addressing) for a memory call, it actually activates $\mathcal{O}(2^n)$ gates to implement it.

However, as they said in the introduction of the paper (V. Giovannetti 2008):

A classical RAM that uses the bucket-brigade (ps. introduced in this paper.) addressing schemes need only activate $\mathcal{O}(n=\log N)$ transistors in the course of a memory call, in contrast with a conventional RAM that activates $\mathcal{O}(2^n=N)$ transistors. As a result, a RAM that uses our design might operate with less dissipation and power consumption than a conventional RAM. Note, however, that energy costs in the memory addressing are not sufficiently high in current RAM chips to justify an immediate adoption of the bucket brigade. Other source of inefficiencies and dissipations are currently predominant (mostly in the memory cells themselves). However, new promising memory cell technologies are being developed (e.g., the “memristor” cells), which would drastically cut back cell dissipation, so that cutting back dissipation in the addressing may become important in the future.

Their architecture can also offer advantages for classical RAM, but it cannot resolve the dominant problem of classical RAM. According to this (stackexchange answer):

I think that it would indeed work in classical RAM, but the hardware constraints didn’t supply the ’evolutionary pressure’ required for it to be develiped and implemented.

currently bucket-brigade architecture is still focused on resolving the quantum issue, like resource efficiency and fault tolerance. (A. Paler 2020)

The bucket-brigade architecture is proposed to resolve the issue that in conventional one, there are always few addressing bits related to exponentially many transistors to control the path. Like the bits controlling the last level of the tree, which needs to control $2^{n-1}$ transistors. This property makes it hard to work in a quantal way, in which decoherence led by many body interaction should be forbidden.

Bucket-Brigade architecture modifies every nodes in the bifurcation tree into a (qu)trit, which could have three possible states.

(The figure is cited from github.com/qsharp-community/qram)The $|0⟩,|1⟩$ state of qutrits shares the same operation of original switches: they indicate which next step to choose at this node (referred as $|\text{left}⟩,|\text{right}⟩$ )). While the other state, denoting as $|\text{wait}⟩$ ,, means a waiting node. When a $0,1$ --valued bit encounters it, it “absorb” the information and switch itself into the same value, including the case that incoming bit is at a superposition state. In a memory call, the bits in input register is popped sequentially into a initialized tree (with all nodes at $|\text{wait}⟩$ , state). When the bit encounters a $|0⟩,|1⟩$ node it propagates into the next level. Thus, when the input register becomes empty, a path towards memory cells is constructed. When input register is in a superposition state, it is further a superposition state among many paths with the same amplitude. After the bus qubit has loaded the data, the nodes along addressing path would be recovered to $|\text{wait}⟩$ , for further usage.

This architecture allows a memory call with $\mathcal{O}(n)$ gates activated, and the superposition addressing is potentially supported. Now we show how to use qRAM implement the state-preparation, or classical data loader for quantum computing. Mathematically, we want to achieve the map (C. Ciliberto 2017, A. Prakash 2014)

$$\{x_i{\}}_{i=1}^N\mapsto |x⟩=\frac{1}{\mathcal{A}}\sum _{i,d}{x}_i^d|i,d⟩.$$

where ${\mathcal{A}}^{-1}$ is the normalization factor. This map encoded classical dataset onto the amplitudes instead of basis.

We begin with the vector $\{x_i{\}}_{i=0}^{N-1}$ ,, with qRAM we can prepare the state (with uniform superposition addressing) with ancilla qubits (with the size of $\log N$ ))

$$|\psi ⟩\otimes |0⟩=\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}|i⟩|x_i⟩\otimes |0⟩$$

Now we apply a rotation conditioned by the content in memory cells

$$\begin{array}{rl}|\tilde{x}⟩& =\exp (-\text{i}t\sum _{i=0}^{N-1}(-x_i)|i,x_i⟩⟨i,x_i|\otimes {\sigma }_x)|\psi ⟩\otimes |0⟩\\ & =\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}|i⟩|x_i⟩(|0⟩+\text{i}t{x}_i|1⟩+\mathcal{O}(t^2))\end{array}$$

Thus, with proper post-selection, we can prepare the state of $\sum _{i=0}^{N-1}{x}_i|i⟩$ .. Similar procedure can also applied for general datasets.

Though this fast amplitude encoding is very exciting, however, unfortunately, there is still no one has actually done this. As for do we need a qRAM, the following comment from github.com/qsharp-community/qram gives a nice answer

Sometimes. You’ll need a qRAM, or some more general means of quantum state preparation in quantum machine learning (QML) algorithms that require you to load in classical data, or query an oracle that returns classical data. I’ve heard a number of stories of people working on QML being actively discouraged from doing so because “QML won’t work without a qRAM”. That’s just not true, because many QML algorithms do not need a qRAM. Now, whether or not they yield any quantum advantage is a separate question, and won’t be discussed here. The key point is that some QML algorithms need a qRAM, and they will potentially run into trouble as per the next question.

the next question mentioned

Can we design an efficient qRAM?

Maybe. In the primer we’ll take a look at proposals that will in principle run in polynomial depth, and others that scale far worse. There are some very interesting qubit-time tradeoffs one can explore, in particular if the data being stored has some sort of underlying structure. Regardless, even if we can design an efficient circuit, we’d also like something that is efficient in a fault-tolerant setting, and this is potentially very expensive.

Another discussion can be found at the paper (C. Ciliberto 2017), in which the author list three issues for the current qRAM research:

1. Do all components of the qRAM require to be error-corrected. If the answer is yes, such exponential physical resources would not be built in an experimental setting.
2. The comparison is thought as unfair (D. Steiger’s talk in 2016). The argument states that the benchmark should be done with the same hardware resources scaling, which might decrease the quantum-speedup. The qRAM-based algorithms should be carefully considered.
3. As pointed out in (S. Aaronson 2015), the fast state preparation based on qRAM requires the classical data distributed relatively uniform. However, in this case, classical random algorithm can be quite fast and reliable, which also makes the exponential-speedup disappeared.

Quantum Linear Algebra

Though the idea about using quantum resources to enhance the learning algorithms had attracted much attention since 1990s, the rapid growth of quantum machine learning actually began in 2009, by the help of quantum algorithm for linear system. In this section we discuss the algorithm, named as HHL algorithm, after its inventor Harrow, Hassidim, and Lloyd. (HHL 2009).

HHL algorithm try to solve the linear system reads

$$\mathit{A}\mathit{x}=\mathit{b}\iff \left[\begin{array}{cc}\mathbf{0}& \mathit{A}\\ {\mathit{A}}^{†}& \mathbf{0}\end{array}\right]\left[\begin{array}{c}\mathbf{0}\\ \mathit{x}\end{array}\right]=\left[\begin{array}{c}\mathit{b}\\ \mathbf{0}\end{array}\right]$$

by the map, we can just consider the case of coefficients matrix to be Hermitian. The pseudo-code for HHL algorithm reads

• Input: $|b⟩=\sum _{i=0}^{N-1}{b}_i|i⟩$ ,, unitary matrix $\hat{U}(t)=\exp (\text{i}t\sum _{i,j=0}^{N-1}{A}_{ij}|i⟩⟨j|)\equiv \exp (\text{i}\hat{A}t)$
• Output: The amplitude-encoded solution $|x⟩=\sum _{i=0}^{N-1}{x}_i|i⟩$ ,, in which $\Vert \mathit{A}\mathit{x}-\mathit{b}\Vert <ϵ$
• Notation:
• Start:

  1. Prepare initial state $|{\psi }_0⟩={|0⟩}_a{|0⟩}_c|b⟩$ with the subscript $a,c$ denoting ancilla and controlled

  2. Apply $\log T$ Hadamard gates to make a uniform superposition control register

     $$|{\psi }_0⟩\to |{\psi }_1⟩={|0⟩}_a\otimes \frac{1}{\sqrt{T}}\sum _{\tau =0}^{T-1}{|\tau ⟩}_c\otimes |b⟩$$

  3. Apply a controlled evolution of ${\hat{U}}_c=\sum _{\tau =0}^{T-1}{\hat{I}}_a\otimes (|\tau ⟩⟨\tau |{)}_c\otimes \hat{U}(\tau z/T)$ ..

     $$|{\psi }_1⟩\to |{\psi }_2⟩={\hat{U}}_c|{\psi }_1⟩=\frac{1}{\sqrt{T}}\sum _{\tau =0}^{T-1}{|0⟩}_a{|\tau ⟩}_c\sum _{j=0}^{N-1}{e}^{\text{i}{\lambda }_j\tau z/T}|{\lambda }_j⟩⟨{\lambda }_j|b⟩$$ in which we assume $\hat{A}|{\lambda }_j⟩={\lambda }_j|{\lambda }_j⟩$

  4. Apply the Fourier transform on the control register

     $$|{\psi }_2⟩\to |{\psi }_3⟩=\sum _{j=0}^{N-1}\sum _{\omega =0}^{T-1}{\alpha }_{\omega |j}⟨{\lambda }_j|b⟩{|0⟩}_a{|\omega ⟩}_c|{\lambda }_j⟩$$

     Note the amplitude $|{\alpha }_{\omega |j}|$ is significant only when ${\lambda }_j\approx 2\pi \omega /z={\tilde{\lambda }}_{\omega }$

  5. Apply a controlled rotation on ancilla qubit, controlled by $\omega$ ..

     $$|{\psi }_3⟩\to |{\psi }_4⟩=\sum _{j=0}^{N-1}\sum _{\omega =0}^{T-1}{\alpha }_{\omega |j}⟨{\lambda }_j|b⟩(\sqrt{1-\frac{C^2}{{\tilde{\lambda }}_{\omega }^2}}|0⟩+\frac{C}{{\tilde{\lambda }}_{\omega }}|1⟩{)}_a{|\omega ⟩}_c|{\lambda }_j⟩$$

  6. Initialize the control register and make post-selection that ancilla qubit should be $1$ .. Then the output register

     $$|x⟩\approx \sum _{j=0}^{N-1}\frac{1}{{\lambda }_j}⟨{\lambda }_j|b⟩|{\lambda }_j⟩=|{\mathit{A}}^{-1}\mathit{b}⟩$$

• End

Phase Estimation

The Phase Estimation algorithm tries to find an eigenvalue of given unitary operator - $\hat{U}$ with the eigenvector $|\psi ⟩$ given. i.e., to find the value of $\theta \in [0,1)$ in the equation(Wikipedia/Quantum_phase_estimation_algorithm)

$$\hat{U}|\psi ⟩=e^{2\pi \text{i}\theta }|\psi ⟩$$

The operation can be implemented by the following circuit. Given $n$ - ---qubit register initialized by $n$ - -- Hadamard gates as

$$|\text{ini}⟩=(\frac{1}{\sqrt{2}}(|0⟩+|1⟩){)}^{\otimes n}\otimes |\psi ⟩$$

Then with $n$ - -- controlled-- $U$ gates operating as

$$\begin{array}{rl}|\text{ini}⟩& \to \underset{j=1}{\overset{n}{⨂}}(|0⟩⟨0|\otimes \hat{I}+|1⟩⟨1|{\hat{U}}^{2^{n-j}}{)}_{\text{on j-th}}|\text{ini}⟩\\ & =\underset{j=1}{\overset{n}{⨂}}\frac{1}{\sqrt{2}}(|0⟩+e^{\text{i}2\pi \theta \times 2^{n-j}}|1⟩)\otimes |\psi ⟩\\ & =\frac{1}{2^{n/2}}\sum _{b_1{b}_2\cdots b_n}(|b_1{b}_2\cdots b_n⟩\exp (\text{i}2\pi \theta \times \sum _{l=1}^n{b}_l{2}^{n-l}))\otimes |\psi ⟩\\ & =\frac{1}{2^{n/2}}\sum _{k=0}^{2^n-1}{e}^{\text{i}2\pi k\theta }|k⟩|\psi ⟩\end{array}$$

Then with quantum Fourier transformation on the $n$ - ---qubit register to find the period of function $e^{\text{i}2\pi \theta k}$ versus $k$ ,----, one gets the value of $\theta$ .. For error limit $ϵ$ ,, phase estimation needs $\mathcal{O}(\log 1/ϵ)$ qubits and $\mathcal{O}(1/ϵ)$ controlled- - $\hat{U}$ gates.

Thus, the core of HHL algorithm is to make a parallel version of phase estimation for $e^{\text{i}\hat{A}t}$ .,, and by controlled rotation together with post-selection to prepare the inverse operator $\sum _j|{\lambda }_j⟩({\lambda }_j{)}^{-1}⟨{\lambda }_j|$ ..

The key of HHL algorithm is the quality of phase estimation subroutine. Ignoring the cost of preparation of $|b⟩$ *, the bottleneck of runtime is simulate the evolution of $e^{\text{i}\hat{A}t}$ .,. In their original paper, they suggest the algorithm in (D. Berry 2006) for sparse matrix and HHL algorithm reaches $\mathcal{O}(\log N({\log }^{\ast }N{)}^2)$ (SuppInfo for HHL). ${\log }^{\ast }N$ (read “log star”) is a slow growth function (Wikipedia/Iterated_logarithm), so usually we thought HHL algorithms has a exponential speedup in this context.

HHL algorithm does have some caveats which make it not an efficient quantum algorithm for linear solver. As discussed in (S. Aaronson 2015), there are at least four critical issues in HHL algorithm

1. The preparation of $|b⟩=\sum b_j|i⟩$ ..
2. The simulation for general $\mathit{A}$ driving quantum evolution. (in (L. Wossnig 2018), an algorithm for dense matrix with complexity of $\tilde{\mathcal{O}}(\sqrt{n})$ .. For soft-O notation see Wikipedia/Big_O_notation)
3. The robustness of inverse the matrix $\mathit{A}$
4. How to extract information encoded in $|x⟩$ .. (For the application of compute ${\mathit{x}}^T\mathit{M}\mathit{x}$ ,, the classical computer can make an estimate within $\mathcal{O}(N)$ time.)

Though with these caveats, HHL algorithm works well as an approximately method for preparation of the solution of $\mathit{A}\mathit{x}=\mathit{b}$ in an amplitude encoded manner. It can be good enough for some applications (for optimization subroutine) like finite element method (A. Montanaro 2016) and linear fitting (N. Wiebe)

Quantum Machine Learning Algorithms

Quantum SVM

Support Vector Machine(SVM) is one of the most important classical learning algorithm mainly for data classification. One of its advantages is that we understand how it works better than most black-box algorithms.

The training set has $N$ data points as $D=\{(x_j;y_j):x_j\in {\mathbb{R}}^d,y_j=\pm 1\}$ .. SVM tries to find a maximum-margin hyperplane with normal vector $w\in {\mathbb{R}}^d$ that divides these points into two classes. Formally, the point $x$ ) , should be separated by the value of $w\cdot x+b$ .. If $w\cdot x+b\ge 1$ ,, then this point is of class $y=1$ .. While $w\cdot x+b\le -1$ it should be of $y=-1$ .. Samples on the margin (i.e. $w\cdot x+b=\pm 1$ are usually called support vectors) The SVM training is to find parameters $w,b$ such that

$$\mathrm{\forall }(x_j;y_j)\in D:y_j(w\cdot x_j+b)\ge 1.$$

and makes the distance between these two classes distant largely enough, i.e., maximize $2/\Vert w\Vert$ .. Thus, the optimization form of SVM training reads

$$\underset{w,b}{min}\frac{1}{2}\Vert w{\Vert }^2\text{ s.t. }{y}_i(w\cdot x_i+b)\ge 1,i=1,\cdots ,N$$

Note: Solution of SVM and time complexity

With $y_i(w\cdot x_i+b)\ge 1$ being linear constraint for $w$ and $b$ ,, the training of SVM is actually a convex optimization problem. The Slater’s condition for convex optimization problem reads (Stephen Boyd’s textbook)

Given convex optimization problem: $$\begin{array}{rl}\text{minimize}& f(x)\\ \text{subject to }& u_i(x)\le 0,i=1,\cdots ,m\\ & v_i(x)=0,i=1,\cdots ,p\end{array}$$ in which $f,u_i$ are convex function, equality constraint functions $v_i(x)=a_i\cdot x+b_i$ are affine. Slater’s condition holds iff there exists an $x$ ) , such that: $$u_i(x)<0,i=1,\cdots ,m;v_i(x)=0,i=1,\cdots ,p$$ Slater’s theorem states that $$\text{Slater's condition holds}\Rightarrow \text{Strong duality holds}$$ i.e., the minimization of origin problem (primal problem) equals to the maximization of (Lagrangian) dual problem, which reads $$\begin{array}{rl}\text{maximize}& g(\lambda ,\nu )=\underset{x}{inf}L(x,\lambda ,\nu )\\ \text{subject to}& {\lambda }_i\le 0,i=1,\cdots ,m\end{array}$$ (note that the infimum does not constrain $x$ ) , ) in which $$L(x,\lambda ,\nu )=f(x)-\sum _{i=1}^m{\lambda }_i{u}_i(x)-\sum _{i=1}^p{\nu }_i{v}_i(x)$$ is the Lagrangian of primal problem.

An important relation between the optimal of primal problem and dual problem is that: if strong duality holds and a dual optimal solution $({\lambda }^{\ast },{\nu }^{\ast })$ exists, then $\mathrm{\forall }x\in F=\{x:u_i(x)\le 0,v_i(x)=0\}:{\lambda }_i{u}_i(x)\ge 0,{\nu }_i{v}_i(x)=0$ .. Thus

$$\underset{x}{inf}L(x,{\lambda }^{\ast },{\nu }^{\ast })=\underset{x\in F}{min}f(x)\Rightarrow x^{\ast }=\arg \underset{x\in F}{min}f(x)=\arg \underset{x}{min}L(x,{\lambda }^{\ast },{\mu }^{\ast })$$

That is, solving the dual problem freely gives us the optimal of primal problem.

Now let us consider the optimization problem of SVM training. The objective function $\Vert w{\Vert }^2/2$ is convex, while the inequality constraints $1-y_i(w\cdot x_i+b)\le 0$ are all convex. Thus, we can use Slater’s theorem to demonstrate the training has strong duality (Only few support vectors are at the boundary of constraints). The Lagrangian:

$$\begin{array}{rl}L(w,b,\lambda )& =\frac{1}{2}\Vert w{\Vert }^2-\sum _{i=1}^N{\lambda }_i(1-y_i(w\cdot x_i+b))\\ \Rightarrow g(\lambda )& =\underset{w\in {\mathbb{R}}^d,b\in \mathbb{R}}{inf}L(w,b,\lambda )=-\sum _{i=1}^N{\lambda }_i-\frac{1}{2}\sum _{i,j=1}^N{\lambda }_i{\lambda }_j{y}_i{y}_j(x_i\cdot x_j)\end{array}$$

in which we optimize of quadratic from of $L(w,b,\lambda )$ with respect to $w,b$ by

$$\begin{array}{rl}\frac{\partial L}{\partial w}{|}_{w=w^{\ast }}=0& \Rightarrow w^{\ast }=-\sum _{i=1}^N{\lambda }_i{y}_i{x}_i\\ \frac{\partial L}{\partial b}{|}_{b=b^{\ast }}=0& \Rightarrow 0=\sum _{i=1}^N{\lambda }_i{y}_i\end{array}$$

Then, primal optimization problem now transforms as dual problem:

$$\begin{array}{rl}\text{maximize}& -\frac{1}{2}{\lambda }^T\mathit{K}\lambda -{\mathbf{1}}^T\lambda \\ \text{subject to}& {\lambda }_i\le 0,i=1,\cdots ,N\\ & y\cdot \lambda =0\end{array}$$

in which, $(\mathit{K}{)}_{i,j}=y_i{y}_j(x_i\cdot x_j)$ ,, $y=(y_1,\cdots ,y_N{)}^T$ ,, and $\mathbf{1}=(1,\cdots ,1{)}^T$

The time complexity of classical training is made up with the following three steps:

1. $\mathcal{O}(N^{2}d)$ .. Construction of the dual problem: $\mathcal{O}(N^2)$ times inner product for $d$ ---vectors
2. $\mathcal{O}(N^3)$ .. For the convex quadratic programming.
3. $\mathcal{O}(Nd)$ .. For the recovery of $w,b$ from dual optimal.

Thus, the total time complexity is of $\mathcal{O}(N^2(d+N))$ .. The reason why use dual form but not primal form is to be capable to kernel tricks: replace $x_i\cdot x_j$ into $k(x_i,x_j)$ for nonlinear support.

In (P. Rebentrost 2014), the quantum speedup of SVM for big data classification is introduced. They use the least squares support vector machine introduced in (J.A.K. Suykens 1999), in which the model is trained by solving a linear system instead of a convex quadratic programming. The training (together with kernel trick) reads:

$$\begin{array}{rl}\text{minimize}& \frac{1}{2}\Vert w{\Vert }^2+\frac{1}{2}\gamma \sum _{i=1}^N{e}_i^2\\ \text{subject to}& w\cdot \varphi (x_i)+b=(1-e_i)y_i,i=1,\cdots ,N\end{array}$$

Such optimization problem with equality constraints can be solved by

$$\begin{array}{rl}\{\begin{array}{ll}{\partial }_{w}L=0& \Rightarrow w=-\sum _{i=1}^N{\lambda }_i\varphi (x_i)\\ {\partial }_{b}L=0& \Rightarrow 0=\sum _{i=1}^N{\lambda }_i\\ {\partial }_{e}L=0& \Rightarrow {\lambda }_i{y}_i=-\gamma e_i\\ {\partial }_{\lambda }L=0& \Rightarrow w\cdot \varphi (x_i)+b=y_i-e_i{y}_i\end{array}& \Rightarrow \left[\begin{array}{cccc}\mathit{I}& 0& 0& \mathit{Z}\\ 0& 0& 0& {\mathbf{1}}^T\\ 0& 0& \gamma \mathit{I}& \text{diag}\mathit{Y}\\ {\mathit{Z}}^T& \mathbf{1}& \text{diag}\mathit{Y}& 0\end{array}\right]\left[\begin{array}{c}w\\ b\\ e\\ \lambda \end{array}\right]=\left[\begin{array}{c}0\\ 0\\ 0\\ y\end{array}\right]\\ & \Rightarrow \left[\begin{array}{cc}0& {\mathbf{1}}^T\\ \mathbf{1}& -{\gamma }^{-1}\mathit{I}-\mathit{K}\end{array}\right]\left[\begin{array}{c}b\\ \lambda \end{array}\right]=\left[\begin{array}{c}0\\ y\end{array}\right]\\ & \Rightarrow \mathit{F}\left[\begin{array}{c}b\\ \lambda \end{array}\right]=\left[\begin{array}{c}0\\ y\end{array}\right]\end{array}$$

in which $\mathit{Z}=[\varphi (x_1),\cdots ,\varphi (x_N)]$ ,, $\text{diag}\mathit{Y}=\text{diag}\{y_1,\cdots ,y_N\}$ ,, and $\mathit{K}={\mathit{Z}}^T\mathit{Z}\Rightarrow (\mathit{K}{)}_{ij}=\varphi (x_i)\cdot \varphi (x_j)=k(x_i,x_j)$ is the kernel matrix, when kernel trick is disabled, $k(x_i,x_j)=x_i\cdot x_j$ ,.. Solving this linear system has time complexity $\mathcal{O}(N^3)$ . (or $\mathcal{O}(N^{2.3})$ for sparse coefficient matrix (D. Coppersmith 1990)).

The quantum SVM use HHL algorithm to find the solution of above linear system in a normalized form as $\hat{F}|b,\lambda ⟩=|y⟩$ ,, in which with the encoding $⟨i|\hat{F}|j⟩=(\mathit{F}/\text{Tr}\mathit{F}{)}_{ij}$ ,, $|y⟩=\sum _{i=1}^N{y}_i|i⟩$ ,, and $|b,\lambda ⟩=b|0⟩+\sum _{i=1}^N{\lambda }_i|i⟩$ .. It would not influence the prediction because the sign of $w\cdot x+b$ is invariant by zooming $w,b$ (or $\lambda ,b$ )) with the same factor. As shown below, the time complexity of training a quantum SVM is $\tilde{\mathcal{O}}(\log N)$ ..

Simulate quantum evolution driven by $\hat{F}$ "

To implement HHL algorithm, we need simulate the unitary operator $e^{\text{i}\mathrm{\Delta }t\hat{F}}$ efficiently. The second order approximation reads

$$⟨i|e^{\text{i}\mathrm{\Delta }t\hat{F}}|j⟩=e^{\text{i}\mathrm{\Delta }t\mathit{J}/\text{Tr}\mathit{F}}\left[\begin{array}{cc}1& 0\\ 0& e^{-\text{i}\gamma \mathrm{\Delta }t/\text{Tr}\mathit{F}}\mathit{I}\end{array}\right]\left[\begin{array}{cc}1& 0\\ 0& e^{-\text{i}\mathrm{\Delta }t\mathit{K}/\text{Tr}\mathit{F}}\end{array}\right]+\mathcal{O}(\mathrm{\Delta }{t}^2)$$

in which

$$\mathit{J}=\left[\begin{array}{cc}0& {\mathbf{1}}^T\\ \mathbf{1}& \mathbf{0}\end{array}\right]$$

The evolution driven by $\mathit{J}$ is straightforward. There are only two nonzero eigenvalues and the corresponding eigenvectors are

$$\hat{J}|J_{\pm }⟩\equiv (\sum _{i=1}^N|0⟩⟨i|+|i⟩⟨0|)|J_{\pm }⟩=\pm \sqrt{N}\times \frac{1}{\sqrt{2}}(|0⟩\pm \frac{1}{\sqrt{N}}\sum _{i=1}^N|i⟩)$$

The basis transformation to diagonalize matrix $\hat{J}$ can be achieved by the following strategy

$$[|0⟩,|1⟩,\cdots ,|N⟩]\to [|0⟩,|1⟩,\cdots ,|N⟩]\left[\begin{array}{ccccc}1& 0& & & \\ 0& 1/\sqrt{N}& & & \\ ⋮& ⋮& & \mathit{R}& \\ 0& 1/\sqrt{N}& & & \end{array}\right]\left[\begin{array}{cc}\mathit{H}& \\ & \mathit{I}\end{array}\right]$$

in which $\mathit{R}$ makes the first transformation unitary, $\mathit{H}$ is a Hadamard gate for $|0⟩,|1⟩$ subspace. With the transform the evolution driven by $\mathit{J}$ can be simulated.

The evolution driven by ${\gamma }^{-1}\mathit{I}$ is trivial, now let us consider how to simulate the evolution driven by $\mathit{K}$ .. With qRAM, one can prepare the state of (by two-level addressing)

$$|x⟩=\frac{1}{\sqrt{N}}\sum _{i=1}^N|i⟩|x_i⟩$$

with $|x_i⟩=\Vert x_i{\Vert }^{-1}\sum _{r=1}^d{x}_i^r|r⟩$ .. Then with the controlled rotation, we can make it to be (like we did in state preparation by qRAM, but now we encode $\Vert x_i\Vert$ instead of $x_i^r$ .. If the norm of each data is stored in qRAM, this procedure is also efficient.)

$$|x⟩=\frac{1}{\sqrt{\sum _{i=1}^N\Vert x_i{\Vert }^2}}\sum _{i=1}^N\Vert x_i\Vert |i⟩|x_i⟩$$

Now, if we discard the dataset register, i.e., partially trace out those $d$ ---dimensional kets, we obtain the kernel matrix as a density matrix

$$\hat{\rho }={\text{Tr}}_2|x⟩⟨x|=\frac{1}{\sum _{i=1}^N\Vert x_i{\Vert }^2}\sum _{i,j=1}^N⟨x_i|x_j⟩\Vert x_i\Vert \Vert x_j\Vert |i⟩⟨j|$$

If the kernel function $k(x_i,x_j)=x_i\cdot x_j$ ,., then it is the value of $⟨x_i|x_j⟩\Vert x_i\Vert \Vert x_j\Vert$ .. With tensor encoding by $|\varphi (x_i)⟩={|x_i⟩}^{\otimes l}$ ,, the coefficients are $⟨\varphi (x_i)|\varphi (x_j)⟩=(⟨x_i|x_j⟩{)}^l$ .. Thus with this trick, one can prepare any polynomial kernel matrix.

Now we have the kernel matrix as $\hat{\rho }=\hat{K}/\text{Tr}\mathit{K}$ .. Since $\text{Tr}\mathit{K}/\text{Tr}\mathit{F}\sim \mathcal{O}(1)$ ,, this time factor would not hurt the efficiency of algorithm. The trace of kernel matrix can be simply estimated by the following procedure:

1. Generate the Hamiltonian $\hat{H}=\sum _{j=1}^N\Vert x_j\Vert |j⟩⟨j|\otimes {\sigma }_x$ by qRAM.

2. Appling $e^{-\text{i}\hat{H}t}$ to the state $|\psi ⟩=\frac{1}{\sqrt{N}}\sum _{j=1}^N|j⟩|0⟩$ .. This results in

   $$|\psi (t)⟩=\frac{1}{\sqrt{N}}\sum _{j=1}^N(\cos (\Vert x_j\Vert t)|j⟩|0⟩-\text{i}\sin (\Vert x_j\Vert t)|j⟩|0⟩)$$

   When $t$ is small enough, the probability to measure the ancilla qubit in $|1⟩$ is $\frac{1}{N}\sum _{j=1}^N\Vert x_j{\Vert }^2{t}^2$ ,, which allows the estimation of the trace of kernel matrix.

The time evolution driven by $\hat{\rho }$ . .,, can be done with the following procedure

$$\begin{array}{rl}{\text{Tr}}_1{e}^{-\text{i}\mathrm{\Delta }t\hat{S}}(\hat{\rho }\otimes \hat{\mu })e^{\text{i}\mathrm{\Delta }t\hat{S}}& =\hat{\mu }-\text{i}\mathrm{\Delta }t{\text{Tr}}_1[\hat{S},\hat{\rho }\otimes \hat{\mu }]+\mathcal{O}(\mathrm{\Delta }{t}^2)\\ & =\hat{\mu }-\text{i}\mathrm{\Delta }t[\hat{\rho },\hat{\mu }]+\mathcal{O}(\mathrm{\Delta }{t}^2)\\ & \approx e^{-\text{i}\mathrm{\Delta }t\hat{\rho }}\hat{\mu }{e}^{\text{i}\mathrm{\Delta }t\hat{\rho }}\end{array}$$

in which we have $\hat{S}=\sum _{m,n=1}^N|m⟩⟨n|\otimes |n⟩⟨m|$ .. Thus, we can implement the evolution driven by $\hat{\rho }$ . .,, efficiently. As shown in (D. Berry 2006), the time complexity is of $\tilde{\mathcal{O}}(\log N\mathrm{\Delta }t)$ .. The bottleneck is the preparation of kernel matrix.

After the training process, i.e., we obtain the amplitude encoding vector $|b,\lambda ⟩$ ,, the prediction for a new item $|x⟩$ . can be done by following steps:

1. query the qRAM of training set with addressing register being $|b,\lambda ⟩$ , then prepare the state of

   $$|u⟩\propto b|0⟩|0⟩+\sum _{k=1}^N{\lambda }_k\Vert x_k\Vert |k⟩|x_k⟩$$

2. Prepare the state of new item:

   $$|\tilde{x}⟩\propto |0⟩|0⟩+\sum _{k=1}^N\Vert x\Vert y_k|k⟩|x⟩$$

3. With an ancilla qubit, prepare the state of (this seems to be a non-trivial process, but it could be efficient on a well-structured qRAM.)

   $$\frac{1}{\sqrt{2}}(|0⟩|u⟩+|1⟩|\tilde{x}⟩)$$

4. Make a measurement on ancilla qubit with the basis of $|\pm ⟩=2^{-1/2}(|0⟩\pm |1⟩)$ ,, the probability to find $|+⟩$ is

   $$\begin{array}{rl}\mathbb{P}(+)& =\frac{1+\text{Re}⟨u|\tilde{x}⟩}{2}\\ \Rightarrow \mathbb{P}(+)-\frac{1}{2}& \propto b+\sum _k{\lambda }_k\Vert x_k\Vert \Vert x\Vert ⟨x|x_k⟩\\ & =b+\sum _k{\lambda }_k{y}_{k}k(x,x_k)\\ & =b+w\cdot x\end{array}$$

   So, the prediction of SVM is $\text{sgn}(\mathbb{P}(+)-1/2)$ ..

Quantum PCA

Principal Component Analysis(PCA) is a typical unsupervised learning algorithm in classical machine learning. For the given dataset $\{x_i^r{\}}_{i=1,\cdots ,N;r=1,\cdots ,d}$ ,, PCA tries to find the principal axes of the ellipsoid determined by the distribution of dataset in ${\mathbb{R}}^d$ .. i.e., it finds the directions along which the variance of dataset projection is maximal (Wikipedia/Principal_component_analysis). Formally, the output of PCA is the solution of the following optimization problem

$$\begin{array}{rl}\text{maximize}& ((x_i-\frac{1}{N}\sum _{i=1}^N{x}_i)\cdot w{)}^2\\ \text{subject to}& w\in {\mathbb{R}}^d\\ & \Vert w\Vert =1\end{array}$$

It can be reduced into an eigensystem problem, with omitting the principal components whose eigenvalues (variance along them) are below the threshold, PCA can also be applied for dimensionality reduction and low-rank approximation.

In 2014, S. Lloyd et al proposed the quantum version of PCA (S. Lloyd 2014). The algorithm is based on the HHL algorithm for matrix inversion, thus authors claim their algorithm is exponentially faster than classical case. (but it still sufferes the caveats of HHL algorithm).

The algorithm begins with a pure quantum way, different from SVM, qRAM is optional for qPCA. We follow the paper (S. Lloyd 2014), the relation between qPCA and classical case will be discussed at the end of this part. Given $n$ - -- copies of quantum state $\hat{\rho }$ . .,, , with the similar strategy in SVM, we can simulate the time evolution of

$$\hat{\mu }(t)=e^{-\text{i}\hat{\rho }t}\hat{\mu }(0)e^{\text{i}\hat{\rho }t}$$

efficiently. Thus, with the controlled time evolution and phase estimation, we can prepare the state of (with spectrum decomposition of $\hat{\rho }=\sum _{i=1}^{\mathcal{D}}{p}_i|{\chi }_i⟩⟨{\chi }_i|$ )):

$$\begin{array}{rl}\sum _t|t⟩\otimes e^{-\text{i}\hat{\rho }t}|\psi ⟩& \to \sum _{\omega }|\omega ⟩{\delta }_{\omega ,p_i}\otimes \sum _{i=1}^{\mathcal{D}}|{\chi }_i⟩⟨{\chi }_i|\psi ⟩\\ & \to \sum _{i=1}^{\mathcal{D}}|p_i⟩\otimes |{\chi }_i⟩⟨{\chi }_i|\psi ⟩\end{array}$$

Apply this subroutine on initial state of $\hat{\rho }$ . .,, , together with the controlled rotation, we actually achieve the state of

$$\sum _{i=1}^{\mathcal{D}}{p}_i|p_i⟩⟨p_i|\otimes |{\chi }_i⟩⟨{\chi }_i|$$

The first part is the register storing the eigenvalue of $\hat{\rho }$ . .,, . As an encapsulation, qPCA allows us to reach the map

$$\hat{\rho }\otimes |0⟩⟨0|\stackrel{\text{qPCA}}{\to }\sum _{i=1}^{\mathcal{D}}{p}_i|i⟩⟨i|\otimes |p_i⟩⟨p_i|$$

within exponentially short time complexity than classical case, if the number of copies of $\hat{\rho }$ . .,, is enough (polynomially dependent of the precision requirement).

Implement qPCA on classical dataset

For classical dataset, qPCA requires qRAM to load data and encode them into amplitude efficiently. When the center-shifted data (i.e., $\sum _{i=1}^N{x}_i=0$ )) is loaded as

$$\frac{1}{\sqrt{N}}\sum _{r=1}^d\frac{1}{\Vert x^r\Vert }\sum _{i=1}^N{x}_i^r|i⟩|r⟩\underset{\text{post selection}}{\overset{\text{ancilla rotation}}{\to }}|D⟩=\frac{1}{\sqrt{\sum _{r=1}^d\Vert x^r{\Vert }^2}}\sum _{r=1}^d\Vert x^r\Vert |r⟩|x^r⟩$$

where $|x^r⟩=\Vert x^r{\Vert }^{-1}\sum _{i=1}^N{x}_i^r|i⟩$ and $\Vert x^r\Vert =\sum _{i=1}^N(x_i^r{)}^2$ .. Then by controlled rotation and partial trace (like we did in SVM, but here we exchange the indices of data entry and feature index), we can prepare the state of:

$$\hat{\rho }={\text{Tr}}_1|D⟩⟨D|=\frac{1}{\sum _{r=1}^d\Vert x^r{\Vert }^2}\sum _{r,r^{\prime }=1}^d|r⟩(\sum _{i=1}^N{x}_i^r{x}_i^{r^{\prime }})⟨r^{\prime }|$$

Thus, use this state as the initial state of qPCA, we can implement the qPCA for classical data.

In a recent paper (T. Xin 2021), an experimental protocol for quantum PCA has been proposed. Different from the above algorithm to find an approach for general density matrix, they use parameterized quantum circuit to find the decomposition for a fixed matrix by training set. With such variational and hybrid classical quantum approach, they claim their protocol could work well on near-term quantum device.

The goal of their qPCA is to find the diagonalization of the given matrix $\hat{\rho }=\sum _{i=1}^{\mathcal{D}}{p}_i|{\psi }_i⟩⟨{\psi }_i|$ where $|{\psi }_i⟩$ mutually orthogonal and $p_1\ge p_2\ge \cdots \ge p_{\mathcal{D}}$ ,, i.e.

$$\hat{U}\hat{\rho }{\hat{U}}^{†}=\sum _{i=1}^{\mathcal{D}}{p}_i|i⟩⟨i|$$

The theoretical support is:

[Theorem] : Given a semidefinite positive and non-degenerate Hermitian operator $\hat{A}=\sum _{j=1}^{\mathcal{D}}{\lambda }_j|j⟩⟨j|$ with $|j⟩$ the eigenstate with eigenvalue ${\lambda }_j$ ,, assuming $0\le {\lambda }_1<{\lambda }_2<\cdots <{\lambda }_{\mathcal{D}}$ and $\sum _{j=1}^{\mathcal{D}}{\lambda }_j=1$ .. One example is $\hat{A}=\frac{1}{N(N-1)}\sum _{j=1}^{\mathcal{D}}{2}^{j-1}({\hat{Z}}_j+1)$ in which ${\hat{Z}}_j$ is Pauli-- $Z$ at $j$ --th site. Then the solution of the following optimization problem

$$\begin{array}{rl}\text{minimize}& \text{Tr}(\hat{U}\hat{\rho }{\hat{U}}^{†}\hat{A})\\ \text{subject to}& {\hat{U}}^{†}\hat{U}=\hat{1}\end{array}$$

would diagonalize $\hat{\rho }$ . .,, in the computational basis, i.e., $\hat{U}\hat{\rho }{\hat{U}}^{†}=\sum _{i=1}^{\mathcal{D}}{p}_i|i⟩⟨i|$ ..

Proof

Given objection function

$$\begin{array}{rl}L(\hat{U})& =\text{Tr}(\hat{U}\hat{\rho }{\hat{U}}^{†}\hat{A})\\ & =\sum _{i,j=1}^{\mathcal{D}}{p}_i{\lambda }_j|⟨{\psi }_i|{\hat{U}}^{†}|j⟩{|}^2\\ & ={\mathit{p}}^T\mathbf{\Pi }\mathit{\lambda }\end{array}$$

where ${\mathit{p}}^T=(p_1,\cdots ,p_{\mathcal{D}}),{\mathit{\lambda }}^T=({\lambda }_1,\cdots ,{\lambda }_{\mathcal{D}})$ ,, and $(\mathbf{\Pi }{)}_{ij}=|⟨{\psi }_i|{\hat{U}}^{†}|j⟩{|}^2$ .. By Birkhoff-von Neumann decomposition (Wikipedia/Doubly_stochastic_matrix), such matrix can be write as the weighted average of a set of permutation matrix. i.e.,

$$\mathbf{\Pi }=\sum _{l=1}^k{\theta }_l{\mathit{P}}_l$$

in which ${\mathit{P}}_l$ are permutation matrix, and ${\theta }_l\ge 0,\sum _{l=1}^k{\theta }_l=1$ .. Then with rearrangement iequality:

$$x_1\le x_2\le \cdots \le x_n\text{ and }{y}_1\le \cdots y_n\Rightarrow \sum _{k=1}^n{x}_k{y}_{n+1-k}\le \sum _{k=1}^n{x}_k{y}_{\sigma (k)}\le \sum _{k=1}^n{x}_k{y}_k$$

we have:

$$L(\hat{U})={\mathit{p}}^T\mathbf{\Pi }\mathit{\lambda }=\sum _{l=1}^k{\theta }_l{\mathit{p}}^T{\mathit{P}}_l\mathit{\lambda }\ge {\mathit{p}}^T\mathit{\lambda }$$

Note that with the protocol, $\mathit{\lambda }$ and $\mathit{p}$ have the reverted order. And this lower bound is compact. With the condition that $\mathit{\lambda }$ is non-degenerate, if $\hat{\rho }$ . .,, is also non-degenerate, the solution should be unique such that $⟨{\psi }_i|{\hat{U}}^{†}|j⟩={\delta }_{ij}$ holds. Otherwise, the permutation or re-combination in degenerated subspace is allowed, but it does not hurt the spectrum decomposition of $\hat{\rho }$ . .,, . The theorem gets proved.

The qPCA via VQC (variational quantum circuit) is to minimize the objection function

$$L(\mathit{z})=\text{Tr}(\hat{U}(\mathit{z})\hat{\rho }\hat{U}(\mathit{z}{)}^{†}\hat{A})$$

with the parameterized circuit $\hat{U}(\mathit{z})$ by gradient descent. In their main text, they used three different type circuits to implement the algorithm.

Fast-grad for VQC

In the paper, they used the VQC of form

$$\hat{U}(\mathit{z})=\prod _{l\in \text{Layers}}(\prod _i\prod _{j\in F_i}{\text{CNOT}}_{i,j}\prod _i{e}^{\text{i}{z}_i{\sigma }_i^y})$$

in which set $F_i$ denotes the qubits connected to $i$ --th qubit with $\text{CNOT}$ gate. This type can be easily to compute the gradient, with the property that:

$${\hat{H}}^2=\hat{1}\Rightarrow [\hat{H},\hat{O}]=\text{i}(e^{-\text{i}\hat{H}\pi /4}\hat{O}{e}^{\text{i}\hat{H}\pi /4}-e^{\text{i}\hat{H}\pi /4}\hat{O}{e}^{-\text{i}\hat{H}\pi /4})$$

This can be proved by noticing $e^{-\text{i}\varphi \hat{H}}=\cos \varphi -\text{i}\sin \varphi \hat{H}$

$$\begin{array}{rl}\text{r.h.s.}& =\text{i}(e^{-\text{i}\hat{H}\pi /4}\hat{O}{e}^{\text{i}\hat{H}\pi /4}-e^{\text{i}\hat{H}\pi /4}\hat{O}{e}^{-\text{i}\hat{H}\pi /4})\\ & =\text{i}((\frac{\sqrt{2}}{2}-\text{i}\frac{\sqrt{2}}{2}\hat{H})\hat{O}(\frac{\sqrt{2}}{2}+\text{i}\frac{\sqrt{2}}{2}\hat{H})-(\frac{\sqrt{2}}{2}+\text{i}\frac{\sqrt{2}}{2}\hat{H})\hat{O}(\frac{\sqrt{2}}{2}-\text{i}\frac{\sqrt{2}}{2}\hat{H}))\\ & =\text{i}(-\frac{\text{i}}{2}\hat{H}\hat{O}+\frac{\text{i}}{2}\hat{O}\hat{H}+\text{c.c.})\\ & =[\hat{H},\hat{O}]=\text{l.h.s.}\end{array}$$

Thus, the gradient of objection with $F(\mathit{z})=⟨{\hat{U}}^{†}(\mathit{z})\hat{O}\hat{U}(\mathit{z})⟩$ is

$$\begin{array}{rl}{\partial }_{j}F(\mathit{z})& =⟨\prod _{k=1}^{j-1}{\hat{U}}_k^{†}(z_k){\partial }_z{\hat{U}}_j^{†}(z_j)\prod _{k=j+1}^K{\hat{U}}_k^{†}(z_k)\hat{O}\hat{U}(\mathit{z})⟩+⟨{\hat{U}}^{†}(\mathit{z})\hat{O}\prod _{k=j+1}^K{\hat{U}}_k^{†}(z_k){\partial }_z{\hat{U}}_j^{†}(z_j)\prod _{k=1}^{j-1}{\hat{U}}_k^{†}(z_k)⟩\\ & =-\text{i}⟨{\hat{U}}_{1\to j-1}^{†}[{\hat{H}}_j,{\hat{U}}_{j\to K}^{†}\hat{O}{\hat{U}}_{K\to j}]{\hat{U}}_{j-1\to 1}⟩\\ & =⟨{\hat{U}}_{1\to j-1}^{†}{\hat{U}}_j^{†}(\pi /4){\hat{U}}_{j\to K}^{†}\hat{O}{\hat{U}}_{K\to j}{\hat{U}}_j(\pi /4){\hat{U}}_{j-1\to 1}⟩-(\pi /4\leftrightarrow -\pi /4)\\ & =F(z_j+\pi /4)-F(z_j-\pi /4)\end{array}$$

Thus, the gradient can be obtained efficiently.