Circuit Depth Reduction for Gate-Model Quantum Computers

Abstract

Quantum computers utilize the fundamentals of quantum mechanics to solve computational problems more efficiently than traditional computers. Gate-model quantum computers are fundamental to implement near-term quantum computer architectures and quantum devices. Here, a quantum algorithm is defined for the circuit depth reduction of gate-model quantum computers. The proposed solution evaluates the reduced time complexity equivalent of a reference quantum circuit. We prove the complexity of the quantum algorithm and the achievable reduction in circuit depth. The method provides a tractable solution to reduce the time complexity and physical layer costs of quantum computers.

Introduction

Gate-model quantum computers are realized by unitary operators (quantum gates) and quantum states^1–29. As the technological limits of current semiconductor technologies will be reached within the next few years^30–40, fundamentally different solutions provided by quantum technologies will be significant in the experimental realization of future computations^{15–18,31,32,41–72}. A quantum computer is set up with a quantum gate structure, that is, via a set of unitary operators. These quantum gates can realize different quantum operations and can be defined on different numbers of input quantum states^{15–18,41–43,45,52,53}. In a quantum computer environment, the depth of the quantum gate structure refers to the number of time steps (time complexity) required for the quantum operations making up the circuit to run on the quantum hardware^{15–18,41–43,45,52–59}. A crucial problem here is the time complexity reduction of the quantum gate structure of the quantum computer. Practically, this problem is such that an equivalent quantum state of the output quantum state of the original the reference quantum circuit (e.g., non-reduced time complexity circuit) can be obtained using a reduced time complexity quantum gate structure. Particularly, currently there exists no plausible and implementable solution for the time complexity reduction of quantum computers. Gate-model quantum computer implementations are affected by the problem of high time complexities and a universal (i.e., platform independent) and tractable solution for the time complexity reduction is essential. Relevant implication of this problem is the high economic cost of the physical apparatuses required for experimentally implementing practical quantum computation: specifically, the high economic cost of the high-precision quantum hardware elements required in the implementation of high-performance quantum circuits.

The quantum circuit of the quantum computer is modeled as an arbitrary quantum circuit with an arbitrary circuit depth formulated via a unitary sequence of L unitary operators. Each unitary is set via a particular Pauli operator and gate parameter (see also Section 2 for a detailed description). The input problem fed into the quantum computer is an arbitrary computational problem $\mathcal{P}$ with an objective function C. The C objective function is a subject of maximization via the quantum computer, i.e., via the unitaries of the circuit structure of the quantum computer. The objective function can model arbitrary combinatorial optimization problems^9,10,42, large-scale programming problems¹⁰ such as the graph coloring problem, molecular conformation problem, job-shop scheduling problem, manufacturing cell formation problem, or the vehicle routing problem¹⁰. For a detailed description of input problems, we suggest^{2–4,8–10,42–45}.

Another important application of gate-model quantum computations is the near-term quantum devices of the quantum Internet^{20,30,36–39,46–49,59,61,62,73–93}.

Here, we define a quantum algorithm for the time complexity reduction of any quantum circuit of quantum computers set up with an arbitrary number of unitary gates. The aim of the proposed framework is to reduce the time complexity of an arbitrary reference quantum circuit and a maximization of the objective function of the computational problem fed into the quantum computer. The method defines the reduced time complexity equivalent of the reference quantum circuit and recovers the reference output quantum state via the reduced time complexity quantum circuit (Note: the terminology of quantum state refers to an input or output quantum system, while the terminology of quantum gate refers to a unitary operator.). The reduced structures are determined via a pre-processing phase in the logical layer, and only the reduced time complexity quantum circuit and reduced quantum state are implemented in the physical layer. The pre-rocessing phase integrates a machine learning^94–97 unit for the parameter optimization. The high complexity reference quantum circuit and reference quantum input are characterized only in the pre-processing phase without any physical level implementation. The framework applies a quantum algorithm on the output of the reduced quantum gate structure to recover the equivalent quantum state of the output quantum state of the non-reduced reference structure. In particular, the proposed framework and the defined quantum algorithm are universal since they have no requirements for the structure of the reference (e.g., non-reduced) quantum circuit subject to be reduced, for the number of unitaries in the reference structure, for the size of the input quantum state of the reference quantum circuit, nor for the dimensions of the actual quantum state. The quantum algorithm is defined as a fixed, auxiliary hardware component for an arbitrary quantum computer environment, with a pre-determined constant computational complexity as an auxiliary cost of the application of the algorithm. Specifically, we prove that the auxiliary cost of the proposed quantum algorithm is orders lower than the reachable amount of the reduction in time complexity, and the computational cost of the quantum algorithm becomes negligible in practice. The method also allows significantly reducing the economic cost of physical layer implementations, since the required elements and high-cost hardware components can be reduced in an experimental setting.

The novel contributions of our manuscript are as follows:

1. We define a quantum algorithm for circuit depth reduction of quantum circuits of gate-model quantum computers.

2. We define the computational cost of the proposed quantum algorithm and prove that it is significantly lower than the gainable reduction in time complexity.

3. The algorithm provides a tractable solution to reduce circuit depth and the economic cost of implementing the physical layer quantum computer by reducing quantum hardware elements.

4. The results are useful for experimental gate-model quantum computations and near-term quantum devices of the quantum Internet.

This paper is organized as follows. Section 2 defines the system model. Section 3 proposes the quantum algorithm and proves the computational complexity. Section 4 discusses the performance of the algorithm. Finally, Section 5 concludes the results. Supplemental material is included in the Appendix.

System Model

Let QG₀ be a reference quantum circuit (quantum gate structure) with a sequence of L unitaries⁴², defined as

$$U\left(\vec{\theta }\right)=U_L\left({\theta }_L\right)U_{L-1}\left({\theta }_{L-1}\right)\dots U_1\left({\theta }_1\right),$$ 1

where $\vec{\theta }$ is the L-dimensional vector of the gate parameters of the unitaries (gate parameter vector),

$$\vec{\theta }={\left({\theta }_1,\dots ,{\theta }_L\right)}^T,$$ 2

and an i-th unitary gate U_i(θ_i) is evaluated as

$$U_i\left({\theta }_i\right)=\exp \left(-i{\theta }_i{P}_i\right),$$ 3

where P_i is a generalized Pauli operator acting on a few quantum states (qubits in an experimental setting) formulated by the tensor product of Pauli operators {σ_x, σ_y, σ_z}⁴². Note, that $U\left(\vec{\theta }\right)$ in (1) identifies a unitary resulted from the serial application of the L unitary operators U_L(θ_L)U_L−1(θ_L−1) … U₁(θ₁), and for an input quantum state |φ〉,

$$U\left(\vec{\theta }\right)|\phi \rangle =U_L\left({\theta }_L\right)U_{L-1}\left({\theta }_{L-1}\right)\dots U_1\left({\theta }_1\right)|\phi \rangle .$$ 4

A qubit system example with a sequence of L unitaries is as follows. Let assume that the QG₀ structure of the quantum computer consists of g single-qubit and m two-qubit unitaries, L = g + m, such that a j-th single-qubit gate realizes an $X_j={\sigma }_x^j$ operator, while a two-qubit gate realizes a $Z_j{Z}_k={\sigma }_z^j{\sigma }_z^k$ operator (see also⁴²). Then, at a particular objective function C of an arbitrary computational problem subject of a maximization via the quantum computer, the $U\left(\vec{\theta }\right)$ sequence from (1) can be rewritten as

$$U\left(\vec{\theta }\right)=U(B,\vec{\beta })U(C,\vec{\gamma }),$$ 5

where

$$U(B,\vec{\beta })=\prod _{j}U\left(B_j,{\beta }_j\right),$$ 6

where $\vec{\beta }$ is the gate parameter vector of the g single-qubit unitaries,

$$\vec{\beta }={\left({\beta }_1,\dots ,{\beta }_g\right)}^T,$$ 7

while B is defined as

$$B=\sum _j{X}_j$$ 8

with

$$X_j={\sigma }_x^j,$$ 9

and

$$U\left(B_j,{\beta }_j\right)=\exp \left(-i{\beta }_j{X}_j\right),$$ 10

where B_j = X_j, while the two-qubit unitaries are defined as

$$U(C,\vec{\gamma })=\prod _{\langle jk\rangle \in Q{G}_0}U\left(C_{jk},{\gamma }_{jk}\right),$$ 11

where 〈jk〉 ∈ QG₀ is a physical connection between qubits j and k in the hardware-level of the QG₀ structure of the quantum computer, $\vec{\gamma }$ is the gate parameter vector of the m two-qubit unitaries

$$\vec{\gamma }={\left({\gamma }_1,\dots ,{\gamma }_m\right)}^T,$$ 12

while

$$C=\sum _{\langle jk\rangle \in Q{G}_0}{C}_{jk},$$ 13

where C_jk is a component of the objective function, while unitary U(C_jk, γ_jk) for a given 〈jk〉 is defined as

$$U\left(C_{jk},{\gamma }_{jk}\right)=U\left(Z_j{Z}_k,{\gamma }_{jk}{C}_{jk}\right)=\exp \left(-i{\gamma }_{jk}{C}_{jk}{Z}_j{Z}_k\right),$$ 14

where

$$Z_j{Z}_k={\sigma }_z^j{\sigma }_z^k.$$ 15

At a particular physical connectivity of QG₀, the objective function C therefore can be written as

$$C\left(z\right)=\sum _{\langle jk\rangle \in Q{G}_0}{C}_{jk}\left(z\right),$$ 16

where C_jk(z) is the objective function component evaluated for a given 〈jk〉, as

$$C_{\langle jk\rangle }\left(z\right)=\frac{1}{2}(1-z_i{z}_j),$$ 17

while z is an N-length input bitstring,

$$z=z_1{z}_2\dots z_N,$$ 18

where z_i identifies an i-th bit, z_i ∈ {−1, 1}.

For a given z, a |z〉 computational basis state is defined as

$$|z\rangle =|z_1{z}_2\dots z_N\rangle ,$$ 19

and the |ϕ〉 output system of QG₀ is as

$$|\varphi \rangle =U\left(\vec{\theta }\right)|z\rangle ,$$ 20

that can be evaluated further via (6) and (11), as

$$\begin{array}{lll}\hfill |\varphi \rangle & \hfill =\hfill & U(B,\vec{\beta })U(C,\vec{\gamma })|z\rangle \hfill \\ \hfill & \hfill =\hfill & \prod _{j}U\left(B_j,{\beta }_j\right)\prod _{\langle jk\rangle \in Q{G}_0}U\left(C_{jk}\left(z\right),{\gamma }_{jk}\right)|z\rangle \hfill \\ \hfill & \hfill =\hfill & \prod _j\exp \left(-i{\beta }_j{X}_j\right)\prod _{\langle jk\rangle \in Q{G}_0}\exp \left(-i{\gamma }_{jk}{C}_{jk}\left(z\right)Z_j{Z}_k\right)|z\rangle .\hfill \end{array}$$ 21

To achieve the quantum parallelism, the input system |φ〉 = |X〉 of the quantum computer is set as an N-length d-dimensional (d = 2 for a qubit system) quantum state in the superposition of all possible d^N states. For a qubit system, it means that input |X〉 is an N-qubit quantum state in a superposition of all possible 2^N states |0〉 to |2^N − 1〉, and the computations are performed on 2^N states in parallel in the quantum computer.

Let |X〉 be a superposed input system of the non-reduced QG₀ gate structure:

$$|X\rangle =\frac{1}{\sqrt{d^N}}\sum _{x_i=1}^{d^N}|x_i\rangle ,$$ 22

where |x_i〉 is an i-th input state (represented as an N-length bit string for a qubit system), i = 1, …, n, n = d^N, of the QG₀ structure of the quantum computer.

To describe the parallel processing of the n input vectors of |X〉 (see (22)), {|x₁〉, …, |x_n〉} of |X〉 (see (22)) in the quantum computer, let ${\vec{\theta }}_i$ be the gate parameter vector associated with a given |x_i〉 of |X〉:

$${\vec{\theta }}_i={\left({\theta }_{i,1},\dots ,{\theta }_{i,L}\right)}^T.$$ 23

Let X be the classical representation of |X〉 in (22) to get

$$X=\frac{1}{\sqrt{d^N}}{\left(x_1,\dots ,x_n\right)}^T,$$ 24

where x_i is the classical representation of |x_i〉. (Note, that X and x_i are not accessible in the quantum computer, since the quantum algorithm operates in the quantum regime on quantum states. The classical representation is used only as an abstracted auxiliary representation to describe the steps of the algorithm in a plausible manner).

Then, let $U_0\left(\vec{\theta }\right)$ be the non-reduced gate structure matrix of QG₀:

$$U_0\left(\vec{\theta }\right)=\left(U_0\right({\vec{\theta }}_n\left)U_0\right({\vec{\theta }}_{n-1}\left)\dots U_0\right({\vec{\theta }}_1\left)\right),$$ 25

where

$$\vec{\theta }=({\vec{\theta }}_1,\dots ,{\vec{\theta }}_n)$$ 26

and $U_0\left({\vec{\theta }}_i\right)$ is the unitary sequence associated with |x_i〉 in QG₀, defined as

$$U_0\left({\vec{\theta }}_i\right)=U_L\left({\theta }_{i,L}\right)U_{L-1}\left({\theta }_{i,L-1}\right)\dots U_1\left({\theta }_{i,1}\right).$$ 27

At an n-dimensional output vector

$$Y=\frac{1}{\sqrt{d^N}}{\left(y_1,\dots ,y_n\right)}^T,$$ 28

and the |Y〉 output quantum state of the non-reduced QG₀ structure is

$$|Y\rangle =U_0\left(\vec{\theta }\right)|X\rangle =\frac{1}{\sqrt{d^N}}\sum _{y_i}|y_i\rangle =\frac{1}{\sqrt{d^N}}\sum _{x_i=1}^{d^N}{U}_0\left({\vec{\theta }}_i\right)|x_i\rangle .$$ 29

To define the reduced gate structure, QG^*, it is necessary to find a reduced $U\left({\vec{\theta }}_i^{\prime }\right)$ with a reduced input $|{\tilde{x}}_i\rangle$, for all i.

Then, let $\tilde{X}$ be the classical representation of the reduced quantum state $|\tilde{X}\rangle$ fed into QG^*, as

$$\tilde{X}=\frac{1}{\sqrt{n^{⁎}}}{\left({\tilde{x}}_1,\dots ,{\tilde{x}}_{n^{⁎}}\right)}^T$$ 30

and

$$|\tilde{X}\rangle =\frac{1}{\sqrt{n^{⁎}}}\sum _{{\tilde{x}}_i=1}^{d^{N^{⁎}}}|{\tilde{x}}_i\rangle ,$$ 31

where N^* is the number of d-dimensional (physical) quantum states that formulate $|\tilde{X}\rangle$, n^* = d^N*, while the unitaries $U(\vec{\theta }\prime )$ of QG^* are

$$U(\vec{\theta }\prime )=\left(U\left({\vec{\theta }}_{n^{⁎}}^{\prime }\right)U\left({\vec{\theta }}_{n^{⁎}-1}^{\prime }\right)\dots U\left({\vec{\theta }}_1^{\prime }\right)\right).$$ 32

where

$$\vec{\theta }\prime =({\vec{\theta }}_1^{\prime },\dots ,{\vec{\theta }}_{n^{⁎}}^{\prime })$$ 33

and $U\left({\vec{\theta }}_i^{\prime }\right)$ is the reduced unitary sequence associated with $|{\tilde{x}}_i\rangle$, defined as

$$U\left({\vec{\theta }}_i^{\prime }\right)=U_L\left({\tilde{\theta }}_{i,L}\right)U_{L-1}\left({\tilde{\theta }}_{i,L-1}\right)\dots U_1\left({\tilde{\theta }}_{i,1}\right).$$ 34

The pre-processing phase determines output Z of QG^* as a classical representation

$$Z=U(\vec{\theta }\prime )\tilde{X},$$ 35

and the output quantum state |Z〉 of QG^* therefore yields

$$|Z\rangle =U(\vec{\theta }\prime )|\tilde{X}\rangle .$$ 36

The notations of the system model are also summarized in Table A.1 of the Supplemental Information.

Problem statement

Problems 1–3 summarize the problems to be solved.

Problem 1

Find a classical pre-processing $\mathcal{P}$ for calculating the $|\tilde{X}\rangle$ reduced input system and the gate parameters of the QG* reduced time complexity gate structure.

Problem 2

Find a universal (independent of the number L of the unitaries in QG₀) unitary operator U_R with a set $\mathcal{R}$ of quantum registers to recover output |Y〉 of the non-reduced QG₀ structure from output |Z〉 of the QG* reduced time complexity gate structure.

Problem 3

Determine the time complexity of U_R and the reduction in the overall time complexity of QG*.

Theorems 1–3 give the resolutions of Problems 1–3.

The non-reduced time complexity quantum circuit QG₀ (reference circuit) with an input quantum state |X〉 is showed in Fig. 1(a). Figure 1(b) depicts the system model for the problem resolution. The method is realized via unitary U_R and $\mathcal{P}$ pre-processing, such that U_R is implemented in the physical layer, while $\mathcal{P}$ is only a logical-layer process. Only the reduced input quantum state $|\tilde{X}\rangle$ and the reduced quantum gate structure QG^* must be built up in the physical layer to yield the reference output system |Y〉 of the reference circuit QG₀ via |Y_R〉. In both cases, the output states are measured via a measurement M to get a classical bitring for the objective function evaluation. As a next step, the gate parameter values of the unitaries of the circuits are calibrated until an optimal objective function value is not reached. The calibration of the gate parameters is a separate optimization procedure and its aim is fundamentally differ from the aim of $\mathcal{P}$, and therefore it is not part of the circuit depth reduction method. Note that existing algorithms can be utilized for this task (such as a the algorithms proposed in¹⁹ and²⁰, or some gradient independent methods⁹⁸).

Figure 1.

(a) The non-reduced time complexity quantum circuit QG₀ (reference circuit) with an input quantum state |X〉. The output of QG₀ is |Y〉. The state |Y〉 is measured via a measurement M to get the classical string z to evaluate the objective function C(z). (b) System model of the time complexity reduction scheme. Pre-processing phase $\mathcal{P}$: the Y classical representation of output |Y〉 of QG₀ is pre-processed by the pre-processing unit $\mathcal{P}$. Unit $\mathcal{P}$ contains a $\mathcal{C}$ computational block that outputs a vector κ, fed into an $\mathcal{L}$ machine learning control unit for the Δ error feedback. Unit $\mathcal{P}$ outputs $\tilde{X}$ and the gate parameters of the reduced structure that defines QG^*. Quantum phase: from $\tilde{X}$ and the gate parameters, $|\tilde{X}\rangle$ and QG^* are set up. System $|\tilde{X}\rangle$ is fed into the reduced quantum circuit QG^*. The output of QG^* is |Z〉, which is fed into the U_R recovery quantum algorithm. The U_R quantum operation outputs the |Y_R〉 system, which is the reference output |Y〉 of the reference circuit QG₀. The state |Y_R〉 is measured via a measurement M to get the classical string z_R to evaluate objective function C(z_R).

Pre-processing

Theorem 1

There exists a $\mathcal{P}$ pre-processing to determine the $|\tilde{X}\rangle$ input system and the $U\left({\vec{\theta }}_i^{\prime }\right)$ gate parameters, i = , …, n, for the reduced QG* gate structure for an arbitrary non-reduced QG₀ structure with $U\left({\vec{\theta }}_i\right)$ and input |X〉.

Proof. The $\mathcal{P}$ pre-processing phase can be decomposed as $\mathcal{P}=\mathcal{C}\mathcal{L}$, where $\mathcal{C}$ is a computational block, while $\mathcal{L}$ is a machine learning control block to calibrate the results of $\mathcal{C}$. We first define block $\mathcal{C}$, then discuss $\mathcal{L}$. The $\mathcal{P}$ pre-processing is a procedure to stabilize the output of the reduced quantum circuit. $\mathcal{P}$ is defined between the components $\mathcal{C}$ and $\mathcal{L}$ to evaluate $|\tilde{X}\rangle$ and to set the gate parameters of the reduced quantum circuit structure QG^* using the reference output |Y〉 of QG₀. Note, as the output |Y_R〉 is fed into an M measurement block, the measurement results provide a feedback to calibrate $\mathcal{P}$ in every subroutine of the protocol to produce a final saturated output. The Δ output of the $\mathcal{L}$ machine learning control unit is used as a feedback in unit $\mathcal{C}$. For the definition of Δ, see (116) in Algorithm 1.

In the $\mathcal{C}$ computational block, the reduced $U\left({\vec{\theta }}_i^{\prime }\right)$ and ${\tilde{x}}_i$ are determined for ∀i, in the following manner. Note, since $\mathcal{P}$ outputs the parameters of the reduced quantum gate structure, the extra complexity of a quantum structure can be replaced with classical complexity in the form of machine learning in the proposed framework.

Operation $\mathcal{C}$ sets a one-dimensional discrete cosine transform⁹⁹ in the reduction method, thus a matrix G is defined as a generator matrix to evaluate the output coefficients of $\mathcal{C}$, see later (45). The definition of $\mathcal{C}$ (see later in (40)) comes from the fact that any U unitary operator can be rewritten via the cos and sin functions, and using cosine functions rather than sine functions is critical for a compression⁹⁹. In our setting, this is because fewer cosine functions are needed to approximate a particular U unitary operator.

Let x_i be the classical representation of |x_i〉, and $y_i=U\left({\vec{\theta }}_i\right)x_i$ be the classical representation of |y_i〉. Using the sequences of the L unitaries in (29), define a matrix G with n coefficients a_i, i = 1, …, n, as

$$\begin{array}{lll}\hfill G& \hfill =\hfill & {\left(\begin{array}{ccc}{a}_1& \cdots & a_n\end{array}\right)}^T\hfill \\ \hfill & \hfill =\hfill & \left(\begin{array}{c}\left(\mathrm{\Sigma }{\theta }_1\right)+x_1\\ \left(\mathrm{\Sigma }{\theta }_2\right)+x_2\\ ⋮\\ \left(\mathrm{\Sigma }{\theta }_n\right)+x_n\end{array}\right)=\left(\begin{array}{c}\left({\Sigma }_{j=1}^L{\theta }_{1,j}\right)+x_1\\ \left({\Sigma }_{j=1}^L{\theta }_{2,j}\right)+x_2\\ ⋮\\ \left({\Sigma }_{j=1}^L{\theta }_{n,j}\right)+x_n\end{array}\right),\hfill \end{array}$$ 37

where

$$\mathrm{\Sigma }{\theta }_i=\underset{j=1}{\overset{L}{\Sigma }}{\theta }_{i,j},$$ 38

where θ_i,j identifies the gate parameter of a j-th unitary U_i,j(θ) associated to an i-th input x_i, while unitary sequence $U_0\left({\vec{\theta }}_i\right)$ to an i-th input x_i is

$$U_0\left({\vec{\theta }}_i\right)=\exp \left(i\Sigma {\theta }_i{P}_i\right),$$ 39

where P_i is a generalized Pauli operator.

First, the $\mathcal{C}$ operation (one-dimensional discrete cosine transform⁹⁹) is applied to the input matrix G from (37),

$$\mathcal{C}:\left\{c_p,f_i\right\},0\le p,i\le n-1,$$ 40

where c_p is the p-th coefficient of $\mathcal{C}$,

$$c_p=\sum _{i=0}^{n-1}{A}_p{f}_i\cos \frac{\pi (2i+1)p}{2n},$$ 41

where

$$f_i=\sum _{i=0}^{n-1}{A}_p{c}_p\cos \frac{\pi (2i+1)p}{2n},$$ 42

and A_p is

$$A_p=\{\begin{array}{l}\frac{1}{\sqrt{n}},\mathrm{if}p=0\hfill \\ \sqrt{\frac{2}{n}},\mathrm{if}1<p<n\hfill \end{array}.$$ 43

The coefficients of $\mathcal{C}$ defines matrix γ as

$$\begin{array}{lll}\hfill \gamma & \hfill =\hfill & \chi G\hfill \\ \hfill & \hfill =\hfill & {\left({\varsigma }_1\cdot G,{\varsigma }_2\cdot G,\dots ,{\varsigma }_n\cdot G\right)}^T\hfill \\ \hfill & \hfill =\hfill & {\left(c_1,c_2,\dots ,c_n\right)}^T,\hfill \end{array}$$ 44

where · is the inner product,

$$c_i={\varsigma }_i\cdot G=\sum _{k=1}^n{\varsigma }_{i,k}\times a_k,$$ 45

where coefficients a_k-s are given in (37), and χ is

$$\chi =\left(\begin{array}{c}{\left({\varsigma }_1\right)}^T\\ ⋮\\ {\left({\varsigma }_{n-1}\right)}^T\\ {\left({\varsigma }_n\right)}^T\end{array}\right),$$ 46

where ς_i is an n-length vector

$${\varsigma }_i=\left({\varsigma }_{i,1},\dots ,{\varsigma }_{i,n}\right)=A_i{\left(\cos \frac{i\pi }{2n},\cos \frac{3i\pi }{2n},\dots ,\cos \frac{(2n-1)i\pi }{2n}\right)}^T.$$ 47

Then, the n-length output vector κ of $\mathcal{C}$ is defined as

$$\mathcal{C}\left(Y\right)=\kappa =\frac{1}{\sqrt{n}}{\left({\mathrm{\Omega }}_1,\dots ,{\mathrm{\Omega }}_n\right)}^T,$$ 48

where Y is given in (28), while Ω_i is as

$$\begin{array}{lll}\hfill {\mathrm{\Omega }}_i& \hfill =\hfill & U\left({\vec{\theta }}_i^{\prime }\right){\tilde{x}}_i\hfill \\ \hfill & \hfill =\hfill & U_L\left({\tilde{\theta }}_{i,L}\right)U_{L-1}\left({\tilde{\theta }}_{i,L-1}\right)\dots U_1\left({\tilde{\theta }}_{i,1}\right){\tilde{x}}_i.\hfill \end{array}$$ 49

Then, using the coefficients (41), (42) and (43) of $\mathcal{C}$, $|{\tilde{x}}_p\rangle$ of the reduced state $|\tilde{X}\rangle$ from (31) can be evaluated via the ${\tilde{x}}_p$ components of $\tilde{X}$ of (30). A p-th input $|{\tilde{x}}_p\rangle$ for QG^* is defined via (49) as

$$|{\tilde{x}}_p\rangle =|{\mathrm{\Omega }}_p{U}^{†}\left({\vec{\theta }}_p^{\prime }\right)\rangle =|\sum _{i=0}^{n-1}{A}_p{x}_i\cos \frac{\pi (2i+1)p}{2n}\rangle ,$$ 50

and the reduced quantum gate sequence $U\left({\vec{\theta }}_p^{\prime }\right)$ of $|{\tilde{x}}_p\rangle$ in QG^*, as

$$U\left({\vec{\theta }}_p^{\mathrm{\prime }}\right)=\exp \left(i\mathrm{\Sigma }{\tilde{\theta }}_p{P}_p\right),$$ 51

where P_p is a generalized Pauli operator, and $\mathrm{\Sigma }{\tilde{\theta }}_p$ is as

$$\mathrm{\Sigma }{\tilde{\theta }}_p=\sum _{i=0}^{n-1}{A}_p\left(\mathrm{\Sigma }{\theta }_i\right)\cos \frac{\pi (2i+1)p}{2n}.$$ 52

Therefore, the quantum state |Z〉 of QG^* is

$$|Z\rangle =U(\vec{\theta }\prime )|\tilde{X}\rangle =\frac{1}{\sqrt{d^{N^{⁎}}}}\sum _{{\tilde{x}}_i=1}^{d^{N^{⁎}}}U({\vec{\theta }}_i^{\prime })|{\tilde{x}}_i\rangle .$$ 53

The description of the $\mathcal{L}$ machine learning control unit is as follows. Unit $\mathcal{L}$ uses the results of $\mathcal{C}$ to provide feedback for the pre-processing via supervised machine learning control.

The $\mathcal{L}$ machine learning algorithm for the pre-processing control is defined in Algorithm 1.

The steps of the $\mathcal{P}$ pre-processing method is given in Procedure 1.

■

Quantum Algorithm

Theorem 2

The |Y〉 output of the non-reduced QG₀ structure can be recovered from the output |Z〉 of the reduced structure QG* via a unitary operator U_R.

Proof. Let $|\tilde{X}\rangle$ be the input quantum state fed into the reduced structure QG^*, and let |Z〉 (see (53)) be the output of the reduced gate structure. The task here is therefore to recover $|Y\rangle =U_0\left(\vec{\theta }\right)|X\rangle$ from |Z〉. The problem is solved via a unitary U_R, as follows.

Without loss of generality, in an i-th step, i = 1, …, n, the goal of the U_R operation is to calculate the quantum state as

$$|{\mathrm{\Phi }}_i\rangle =|{\omega }_i\cdot \kappa \rangle ,$$ 54

where κ is as in (48), while ω_i = (ω_i,1, …, ω_i,n)^T is an n-length vector defined for a given j, as

$${\omega }_j={\left(e^{i\left(\mathrm{\Sigma }{\theta }_1-\mathrm{\Sigma }{\tilde{\theta }}_1\right)}{A}_j\cos \frac{j\pi }{2n},\dots ,e^{i\left(\mathrm{\Sigma }{\theta }_n-\mathrm{\Sigma }{\tilde{\theta }}_n\right)}{A}_j\cos \frac{(2n-1)j\pi }{2n}\right)}^T,$$ 55

where ∑θ_i is as given in

$$\mathrm{\Sigma }{\theta }_i=\sum _{i=0}^{n-1}{A}_p\left(\mathrm{\Sigma }{\tilde{\theta }}_p\right)\cos \frac{\pi (2i+1)p}{2n},$$ 56

where $\mathrm{\Sigma }{\tilde{\theta }}_p$ is given in (52).

Then let

$$W=\left(\begin{array}{c}{\left({\omega }_1\right)}^T\\ ⋮\\ {\left({\omega }_{n-1}\right)}^T\\ {\left({\omega }_n\right)}^T\end{array}\right),$$ 57

such that

$$W\kappa ={\left({\omega }_1\cdot \kappa ,\dots ,{\omega }_n\cdot \kappa \right)}^T.$$ 58

Applying U_R for all i, yields the recovered quantum state |Y_R〉 as

$$\begin{array}{lll}\hfill |Y_R\rangle & \hfill =\hfill & \sum _{i=1}^n|{\mathrm{\Phi }}_i\rangle =\sum _{i=1}^n|{\omega }_i\cdot \kappa \rangle \hfill \\ \hfill & \hfill =\hfill & \frac{1}{\sqrt{n}}\sum _{x_i=1}^n{e}^{i\left(\mathrm{\Sigma }{\theta }_i-\mathrm{\Sigma }{\tilde{\theta }}_i\right)}U({\vec{\theta }}_i\prime )|x_i\rangle \hfill \\ \hfill & \hfill =\hfill & \frac{1}{\sqrt{d^N}}\sum _{x_i=1}^{d^N}{U}_0\left({\vec{\theta }}_i\right)|x_i\rangle \hfill \\ \hfill & \hfill =\hfill & U_0\left(\vec{\theta }\right)|X\rangle ,\hfill \end{array}$$ 59

where an i-th |x_i〉 is as

$$|x_i\rangle =|\sum _{i=0}^{n-1}{A}_p{\tilde{x}}_p\cos \frac{\pi (2i+1)p}{2n}\rangle ,$$ 60

where i ≤ n − 1, and p ≥ 0, and ${\tilde{x}}_p$ is as given in (50); while the $U_0\left({\vec{\theta }}_i\right)$ gate parameters (see (39)) of the L unitaries for a given i are evaluated as

$$\begin{array}{lll}\hfill U_0\left({\vec{\theta }}_i\right)& \hfill =\hfill & e^{i\left(\mathrm{\Sigma }{\theta }_i-\mathrm{\Sigma }{\tilde{\theta }}_i\right)}U\left({\vec{\theta }}_i^{\prime }\right)\hfill \\ \hfill & \hfill =\hfill & e^{i\left(\mathrm{\Sigma }{\theta }_i-\mathrm{\Sigma }{\tilde{\theta }}_i\right)}{e}^{i\mathrm{\Sigma }{\tilde{\theta }}_i{P}_i}\hfill \\ \hfill & \hfill =\hfill & e^{i\mathrm{\Sigma }{\theta }_i{P}_i}.\hfill \end{array}$$ 61

The unitary U_R is defined via a set $\mathcal{R}$ of quantum registers as

$$U_R:\mathcal{R}=\left\{\right|R_1\rangle ,\dots ,|R_7\rangle \},$$ 62

where |R_i〉 is the i-th quantum register. The registers are initialized via set ${\mathcal{R}}_0$ as

$${\mathcal{R}}_0=\left\{\begin{array}{l}|R_1\rangle =|\partial \rangle ,|R_2\rangle =|\eta \rangle ,|R_3\rangle =|i\rangle ,|R_4\rangle =|\kappa \rangle ,\hfill \\ |R_5\rangle =|0\rangle ,|R_6\rangle =|0\rangle ,|R_7\rangle =|0\rangle \hfill \end{array}\right\},$$ 63

where κ is given in (48), while ∂ and η are initial parameters defined as

$$\partial =\frac{{\Vert \kappa \Vert }^2}{n},$$ 64

and

$$\eta ={\Vert \kappa \Vert }^2,$$ 65

where

$${\Vert \kappa \Vert }^2=\kappa \cdot \kappa =\sum _{i=0}^{n-1}\frac{1}{n}({\mathrm{\Omega }}_i\times {\overline{\mathrm{\Omega }}}_i)$$ 66

where ${\mathrm{\Omega }}_i=U\left({\vec{\theta }}_i^{\prime }\right){\tilde{x}}_i$, and

$$\partial \le \frac{1}{n}\left(y_i\times y_i\right)\le \eta ,$$ 67

where $y_i=U\left({\vec{\theta }}_i\right)x_i$.

Then, unitary U_R is defined as

$$U_R=\left(2\right|\psi \rangle \langle \psi |-I)U_S,$$ 68

where

$$|\psi \rangle =\frac{1}{\sqrt{n}}\sum _{i=0}^{n-1}|i\rangle ,$$ 69

and U_S is a unitary defined as

$$U_S={\left(U_0\right)}^{-1}{\left(O_{{\mathrm{\Phi }}_i}\right)}^{-1}{O}_{f_i}{O}_{{\mathrm{\Phi }}_i}{U}_0,$$ 70

with eigenstate

$$|{\mathrm{\Psi }}_S\rangle =|\partial \rangle |\eta \rangle |i\rangle |\kappa \rangle |0\rangle |0\rangle |0\rangle ;$$ 71

where U₀ is an initial unitary operator that prepares state |R₅〉 = |ω_i〉 for a given index state |R₄〉 = |i〉, where ω_i is given in (55); from an initial |R₄〉|R₅〉 = |i〉|0〉 as

$$U_0\left(\right|i\rangle |0\rangle )=|0\oplus {\omega }_i\rangle$$ 72

in the register set ${\mathcal{R}}_0$ (see (63)), where $\oplus$ is the CNOT operation, while $O_{{\mathrm{\Phi }}_i}$ is an oracle applied on ${\mathcal{R}}_0$ to compute Φ_i (54), defined as

$$\begin{array}{l}{O}_{{\mathrm{\Phi }}_i}\left({\mathcal{R}}_0\right)=\mathcal{R}\prime \\ :\left\{\begin{array}{l}|R_1\rangle =|\partial \rangle ,|R_2\rangle =|\eta \rangle ,|R_3\rangle =|i\rangle ,|R_4\rangle =|\kappa \rangle ,\hfill \\ |R_5\rangle =|{\omega }_i\rangle ,|R_6\rangle =|0\rangle ,|R_7\rangle =|{\left({\mathrm{\Phi }}_i\right)}^2\rangle \hfill \end{array}\right\},\end{array}$$ 73

where $\mathcal{R}\prime$ is the resulting register set, while $O_{f_i}$ is an oracle that outputs function f_i, as

$$O_{f_i}:f_i=\{\begin{array}{l}1,\mathrm{if}\partial \le {\left(\frac{1}{\sqrt{n}}{y}_i\right)}^2\le \eta \hfill \\ 0,\mathrm{otherwise}\hfill \end{array}.$$ 74

Specifically, note that (70) changes only the phase of the state as ${(-1)}^{f_i}$, where f_i is given in (74), while

$${\left(U_0\right)}^{-1}{\left(O_{{\mathrm{\Phi }}_i}\right)}^{-1}={\left(O_{{\mathrm{\Phi }}_i}{U}_0\right)}^{-1}.$$ 75

Applying (74) on (63) yields a register state $O_{f_i}\left({\mathcal{R}}_0\right)$ as

$$O_{f_i}\left({\mathcal{R}}_0\right)={(-1)}^{f_i}{\mathcal{R}}_0,$$ 76

where ${\left(-1\right)}^{f_i}$ is the eigenvalue of U_S in (70).

Then, using the register set (63), let |ϕ₀〉 be the input state for U_R as

$$|{\varphi }_0\rangle =\frac{1}{\sqrt{n}}\sum _{i=0}^{n-1}|\partial \rangle |\eta \rangle |i\rangle |\kappa \rangle |0\rangle |0\rangle |0\rangle .$$ 77

Applying (68) k-times on (77) yields

$$|{\varphi }_k\rangle ={\left(U_R\right)}^k|{\varphi }_0\rangle .$$ 78

The k iteration number in (78) is a random number, k < c, where $c=\min \left\{1.2\cdot m,\sqrt{n}\right\}$, and m is initialized as m = 1⁹⁹.

Then let O_Z be an oracle defined on $\mathcal{R}\prime$ as

$$\begin{array}{l}{O}_Z\left(\mathcal{R}\prime \right)={\mathcal{R}}^{⁎}\hfill \\ :\left\{\begin{array}{l}|R_1\rangle =|\partial \rangle ,|R_2\rangle =|\eta \rangle ,|R_3\rangle =|i\rangle ,|R_4\rangle =|\kappa \rangle ,\hfill \\ |R_5\rangle =|{\omega }_i\rangle ,|R_6\rangle =|{\Phi }_i\rangle ,|R_7\rangle =|0\rangle \hfill \end{array}\right\}.\hfill \end{array}$$ 79

Applying O_ZU₀ on (78), outputs system state

$$|{\varphi }^{⁎}\rangle =O_Z{U}_0\left(\right|{\varphi }_k\rangle ).$$ 80

In particular, in system state (80), the state of register |R₆〉 is

$$|R_6\rangle =\sum _{i=1}^n|{\mathrm{\Phi }}_i\rangle =|Y_R\rangle ,$$ 81

therefore yields (59), such that

$$\partial \le {\left({\mathrm{\Phi }}_i\right)}^2\le \eta$$ 82

holds for all i of |Y_R〉, due to the conditions set in the pre-processing procedure $\mathcal{P}$ (see (67)).

Assuming that the input system (77) for U_R is prepared for R-times and the output register (81) is measured for R-times, i.e., U_R is applied for R times in overall, in an r-th repetition, r = 1, …, R, the parameters of the procedure can be valuated as

$${\partial }^{\left(r\right)}=\frac{{\eta }^{\left(r\right)}}{n-q^{\left(r\right)}},$$ 83

where

$${\eta }^{\left(r\right)}={\Vert {\kappa }^{\left(r\right)}\Vert }^2-({\mathrm{\Phi }}_i^{\left(r\right)}\times {\mathrm{\Phi }}_i^{\left(r\right)}),$$ 84

where ${\mathrm{\Phi }}_i^{\left(r\right)}$ is the measured value of |Φ_i〉 in the r-th repetition of U_R, while q^(r) is the number of coefficients have been already found⁹⁹.

The actual value of r requires no increment if the relation

$${\tau }^{\left(r\right)}>\frac{1}{{\Vert \kappa \Vert }^2}{\eta }^{\left(r\right)},$$ 85

holds, where τ^(r) is a threshold value in the r-th iteration. Otherwise, the value of r can be increased, r = r + 1, as r < R.

The steps of the quantum algorithm U_R are given in Algorithm 2.

Distortion measure

As (81) is prepared in Step 4 of U_R, the state |Y_R〉 can be measured to get the classical string z_R to evaluate objective function C(z_R), as follows. Measure register |R₆〉 of $\mathcal{R}$ via a measurement operator M to evaluate objective function C(z_R), where z_R is a classical string resulted from the measurement of |Y_R〉, while C is an objective function of an arbitrary computational problem fed into the quantum computer.

The $\mathcal{D}$ distortion coefficient associated with the |Y_R〉 recovered quantum state (59) can be evaluated at a particular objective function C, associated to the computational problem fed into the quantum computer as

$$\mathcal{D}=\left|C\left(z\right)-C\left(z_R\right)\right|,$$ 86

where z is a classical string resulting from the M measurement of |Y〉, while z_R is a classical string resulting from the M measurement of |Y_R〉.

Precisely, assuming R measurement rounds, an average of distortion yields

$${\mathcal{D}}^{\left(R\right)}=\frac{1}{R}\sum _{r=1}^R\left|C^{\left(r\right)}\left(z\right)-C^{\left(r\right)}\left(z_R\right)\right|,$$ 87

where C^(r)(z) and C^(r)(z_R) are the objective function values respectively associated with z and z_R in the r-th round, r = 1, …, R.

Computational Complexity

Theorem 3

Quantum algorithm U_R can be implemented with time complexity $\mathcal{O}\left(\sqrt{n}\right)$ for the time complexity reduction of any non-reduced QG₀ with an arbitrary number of L unitaries.

Proof. Let

$$\mathcal{G}\left\{|i\rangle |b\rangle |c\rangle \right\}$$ 88

be a global space spanned by |i〉, an n-dimensional vector |b〉, and by |c〉, which represents the inner product state.

Particularly, the U_R unitary in (68) applied on an input |φ〉 formulated via set $\mathcal{R}$ of quantum registers gives

$$\begin{array}{lll}\hfill |\phi \rangle & \hfill =\hfill & \frac{1}{\sqrt{n}}\sum _{i=0}^{n-1}|{\mathrm{\Psi }}_i\rangle \hfill \\ \hfill & \hfill =\hfill & \frac{1}{\sqrt{n}}\sum _{i=0}^{n-1}|\partial \rangle |\eta \rangle |i\rangle |\kappa \rangle |0\rangle |0\rangle |0\rangle ,\hfill \end{array}$$ 89

where

$$|{\mathrm{\Psi }}_i\rangle =|\partial \rangle |\eta \rangle |i\rangle |\kappa \rangle |0\rangle |0\rangle |0\rangle ;$$ 90

thus U_R can be interpreted as a rotation on an n-dimensional subspace $\mathcal{S}\left\{|i\rangle \right\}$, 0 ≤ i < n, i.e., on a span of all |i〉.

Let ∏ be the solution set with conditions (82) for all i of ∏,

$$\mathrm{\Pi }=|\partial \rangle |\eta \rangle |i\rangle |\kappa \rangle |0\rangle |0\rangle |0\rangle ,$$ 91

and let $|\Upsilon \rangle \in \mathcal{S}\left\{|i\rangle \right\}$ be the superposition of all solutions:

$$\begin{array}{lll}\hfill |\Upsilon \rangle & \hfill =\hfill & \frac{1}{\sqrt{\left|\mathrm{\Pi }\right|}}\sum _{\xi \in \mathrm{\Pi }}|\xi \rangle \hfill \\ \hfill & \hfill =\hfill & \frac{1}{\sqrt{\left|\mathrm{\Pi }\right|}}\sum _{\xi \in \mathrm{\Pi }}|\partial \rangle |\eta \rangle \sum _{\mathrm{\Pi }}|i\rangle |\kappa \rangle |0\rangle |0\rangle |0\rangle .\hfill \end{array}$$ 92

The operation U_R on |φ〉 yields the state $|{\varphi }^{⁎}\rangle \in \mathcal{S}\left\{|i\rangle \right\}$ (see (80)):

$$\begin{array}{lll}\hfill |{\varphi }^{⁎}\rangle & \hfill =\hfill & U_R\left(|\phi \rangle \right)\hfill \\ \hfill & \hfill =\hfill & |\partial \rangle |\eta \rangle \left[\left(2|\psi \rangle \langle \psi |-I\right)\sum _{i=0}^{n-1}{(-1)}^{f_i}\frac{1}{\sqrt{n}}|i\rangle \right]|\kappa \rangle |0\rangle |0\rangle |0\rangle \hfill \\ \hfill & \hfill =\hfill & \frac{1}{\sqrt{n-\left|\mathrm{\Pi }\right|}}\sum _{|\alpha \rangle \notin \mathrm{\Pi }}|\alpha \rangle \hfill \\ \hfill & \hfill =\hfill & \frac{1}{\sqrt{n-\left|\mathrm{\Pi }\right|}}|\partial \rangle |\eta \rangle \left(\sum _{I-\mathrm{\Pi }}|j\rangle \right)|\kappa \rangle |0\rangle |0\rangle |0\rangle ,\hfill \end{array}$$ 93

thus, U_R is a rotation on the subspace $\mathcal{S}\left\{|{\varphi }^{⁎}\rangle ,|\Upsilon \rangle \right\}$ by angle ${\theta }_{U_R}$ towards (92), as

$${\theta }_{U_R}=2\arcsin \sqrt{\frac{\left|\mathrm{\Pi }\right|}{n}},$$ 94

where |∏| is the number of solutions (cardinality of solution set ∏).

U_R can be implemented as a rotation of ${\theta }_{U_R}$ on subspace $\mathcal{S}\left\{|i\rangle \right\}$ (instead of a rotation on global space (88)) via a generalized quantum searching¹⁰⁰ that yields time complexity $\mathcal{O}\left(\sqrt{n}\right)$ for an arbitrarily large quantum circuit QG₀. ■

Performance Evaluation

Assuming that the initial time complexity of the QG₀ non-reduced gate structure is

$$\mathcal{O}\left(NL\right),$$ 95

where N is the number of d-dimensional (physical) quantum states in the superposed input system, and L is the number of unitaries in QG₀, the time complexity of the reduced QG^* structure is

$$\mathcal{O}\left(N^{⁎}{L}^{⁎}\right),$$ 96

where N^* is the number of d-dimensional (physical) quantum states in the reduced superposed input system, and L^* is the number of unitaries in the reduced gate structure QG^*.

Since the complexity of the proposed scheme is

$$\mathcal{O}\left(\sqrt{n}\right),$$ 97

the result of (96) is a reduced time complexity with respect to (95), as the relation

$$N^{⁎}{L}^{⁎}<NL-\sqrt{n},$$ 98

holds; thus

$$N^{⁎}{L}^{⁎}<NL-d^{N/2}.$$ 99

The overall complexity of the QG^* reduced structure at the application of U_R is therefore

$$\mathcal{O}\left(N^{⁎}{L}^{⁎}+\sqrt{n}\right)=\mathcal{O}\left(N^{⁎}{L}^{⁎}+d^{N\mathrm{/2}}\right)\mathrm{}.$$ 100

Figure 2 depicts the resulting time complexities for a qubit implementation (N-qubit superposed input system, and qubit gate structure with L unitaries).

Figure 2.

The time complexities (number of operations) for an N-qubit system, d = 2, n = 2^N, with an initial non-reduced gate structure QG₀ with L unitaries, L = {10, 100, 1000, 10000}. The time complexity of QG₀ is $\mathcal{O}\left(NL\right)$, while $\mathcal{O}\left(\ell \right)$ is an upper a bound on $\mathcal{O}\left(N^{⁎}{L}^{⁎}\right)$ of QG^*, $\mathcal{O}\left(\ell \right)=\mathcal{O}\left(NL-\sqrt{n}\right)$.

To achieve time complexity reduction using $|\tilde{X}\rangle$ and QG^* instead of |X〉 and QG₀, the relation $\mathcal{O}\left(N^{⁎}{L}^{⁎}\right)<\mathcal{O}\left(\ell \right)=\mathcal{O}\left(NL-\sqrt{n}\right)$ must be straightforwardly satisfied, i.e., the initial complexity $\mathcal{O}\left(NL\right)$ has to be reduced by more than $\mathcal{O}\left(\sqrt{n}\right)$. Since the complexity of the procedure is independent from the actual size of the gate structure, the cost remains constant $\mathcal{O}\left(\sqrt{n}\right)$ for an arbitrarily large L.

Conclusions

Gate-model quantum computers are equipped with a collection of quantum states and unitary quantum gates. The realization of the quantum circuit of a quantum computer requires high fidelity, high precision, and high-level control. Since both the timecomplexity (depth of the circuits) and the economic costs of these implementations are high in practical scenarios, a reduction of these costs is essential. Here, we defined a quantum algorithm for reducing the circuit depth of gate-model quantum computers. The method achieves a reduction in the physical layer allowing significantly reducing implementation costs. The framework is flexible and can be used for arbitrary circuit depths.

Submission note

Parts of this work were presented in conference proceedings¹⁰¹.

Ethics statement

This work did not involve any active collection of human data.

Appendix

Algorithm 1

$\mathcal{L}$ supervised machine learning control of $\mathcal{C}$

Input: The Ω_i coefficients from block $\mathcal{C}$.

Output: Classification of the Ω_i coefficients, error Θ of $\mathcal{P}$; error Δ of $\mathcal{C}$, updated Ω_i coefficients.

Step 1. Let ${\mathcal{S}}_T$ be the training set of $\mathcal{L}$ as ${\mathcal{S}}_T=\langle \left({\kappa }_1,l_1\right),\dots ,\left({\kappa }_m,l_m\right)\rangle$, where κ_i is an i-th instance and an n-length vector (see (48)) drawn from the input space $\mathcal{X}$, while $l_i\in {\mathcal{S}}_{\ell }$ is the class label associated with κ_i, where ${\mathcal{S}}_{\ell }$ is the set of labels ${\mathcal{S}}_{\ell }=\left\{1,\dots ,k\right\}$.

Step 2. For i = 1, …, m, set the initial D₀(i) distribution of the i-th instance of ${\mathcal{S}}_T$ as $D_0\left(i\right)=\frac{1}{m}$.

Step 3. Set the R iteration number. For an r-th iteration, r = 1, …, R, let D_r be distribution. Define hypothesis (implementable via a weak learning algorithm^102–105) using the input distribution D_r as

$$h_r:\mathcal{X}\to {\mathcal{S}}_{\ell }$$ 101

such that the ε_r training error (error of h_r) of $\mathcal{L}$ is

$${\epsilon }_r={\mathrm{Pr}}_i\left[h_r\left({\kappa }_i\right)\ne l_i\right]={\sum }_{i:h_r\left({\kappa }_i\right)\ne l_i}{D}_r\left(i\right)$$ 102

is minimized with respect to the distribution D_r.

Step 4. If ε_r ≤ 0.5 goto Step 5, otherwise set R = r − 1, and stop.

Step 5. If h_r(κ_i) = l_i, set D_r+1(i) as

$$D_{r+1}\left(i\right)=W_r\frac{D_r\left(i\right)}{{\chi }_r},$$ 103

where χ_r is a normalization term, while W_r is a weighting coefficient, as

$$W_r=\frac{{\epsilon }_r}{1-{\epsilon }_r}.$$ 104

If h_r(κ_i) ≠ l_i, set

$$D_{r+1}\left(i\right)=\frac{D_r\left(i\right)}{{\chi }_r}.$$ 105

Step 6. Repeat steps 3–5 for R times.

Step 7. From the R hypotheses h₁, …, h_R, set the final hypothesis H to classify the Ω_i coefficients and the input system Y as

$$H=\arg \underset{l\in {\mathcal{S}}_{\ell }}{\max }\sum _{r:h_r\left(\kappa \right)=l}\log \frac{1}{W_r},$$ 106

and calculate the ε(H) error of H as

$$\epsilon \left(H\right)=\sum _{i:H\left({\kappa }_i\right)\ne l_i}{D}_H\left(i\right),$$ 107

where D_H is the distribution associated to H.

Step 8. Initialize ${\partial }_{\mathcal{C}}$ and ${\eta }_{\mathcal{C}}$ parameters as

$${\partial }_{\mathcal{C}}=\frac{{\eta }_{\mathcal{C}}}{n},$$ 108

where

$${\eta }_{\mathcal{C}}={\Vert Y\Vert }^2=Y\cdot Y=\sum _{i=1}^n\frac{1}{n}\left(y_i\times y_i\right),$$ 109

where Y is defined in (28), $y_i=U\left({\vec{\theta }}_i\right)x_i$, and

$${\partial }_{\mathcal{C}}\le \left(\frac{1}{n}\left({\mathrm{\Omega }}_i\times {\mathrm{\Omega }}_i\right)\right)\le {\eta }_{\mathcal{C}},$$ 110

where ${\mathrm{\Omega }}_i=U\left({\vec{\theta }\prime }_i\right){\tilde{x}}_i$.

Step 9. For an i-th coefficient Ω_i, set

$${\partial }_{\mathcal{C},i}={\eta }_{\mathcal{C}}-\left(\frac{1}{n}\left({\mathrm{\Omega }}_i\times {\mathrm{\Omega }}_i\right)\right).$$ 111

Step 10. Set σ_i threshold for an i-th coefficient as

$${\sigma }_i=\frac{{\partial }_{\mathcal{C},i}}{{\Vert Y\Vert }^2}.$$ 112

Repeat step 9, until

$${\sigma }_i\ge \varsigma$$ 113

where ς, ς > 0 is defined via the relation

$$\varsigma \ge \gamma =\frac{1}{{\Vert Y\Vert }^2}\sum _{i=1}^B\frac{1}{n}\left({\mathrm{\Omega }}_i\times {\mathrm{\Omega }}_i\right),$$ 114

where B is the number of non-zero elements Ω_i of κ, B ≤ n. If σ_i < ς, goto step 11.

Step 11. Output the Θ error of $\mathcal{P}$ as

$$\mathrm{\Theta }={\left(\sum _{i=1}^B{\left|\frac{1}{{\sigma }_i}\left(y_i-{\mathrm{\Omega }}_i\right)\right|}^{\rho }\right)}^{1/\rho }+\epsilon \left(H\right),$$ 115

where ρ is a constant, while ε(H) is given in (107).

Step 12. Output the error Δ of $\mathcal{C}$ as

$$\mathrm{\Delta }=\mathrm{\Theta }-\epsilon \left(H\right).$$ 116

Step 13. According to (116), calibrate the Ω_i coefficients (defined in (49)) of output κ in (48) of $\mathcal{C}$, to yield $\mathrm{\Delta }<\mathcal{E}$ in (115), where $\mathcal{E}$ is a threshold on the error of $\mathcal{P}$.

Procedure 1 Pre-processing $\mathcal{P}$

Input: Output Y (28) of the non-reduced QG₀ reference circuit.

Output: Input $|\tilde{X}\rangle$ (31) of reduced quantum circuit QG^*.

Step 0. Characterize the $U_0\left(\vec{\theta }\right)$ (25) unitaries of the QG₀ reference circuit via gate parameters (33), and the reference input |X〉 (22) via X (24). Evaluate |Y〉 (29) via Y (28).

Step 1. Fed Y into block $\mathcal{C}$ to determine κ (48), and control the results of $\mathcal{C}$ via $\mathcal{L}$.

Step 2. Output $\tilde{X}$ via (30) and produce $|\tilde{X}\rangle$ as (31).

Algorithm 2

Quantum algorithm U_R

Input: Output state |Z〉 (36) of QG^*.

Output: Quantum state |Y_R〉 (59).

Step 1. Prepare the reduced quantum state $|\tilde{X}\rangle$ (30) using $\tilde{X}$ (31) of $\mathcal{P}$.

Step 2. Prepare the unitaries $U(\vec{\theta }\prime )$ of (32) via $\vec{\theta }\prime$ (33) of QG^*.

Step 3. Fed $|\tilde{X}\rangle$ into QG^* to yield output system |Z〉 (36).

Step 4. Utilize the quantum register set $\mathcal{R}$ (63). Apply U_R on $\mathcal{R}$ to get |Y_R〉 (59) in register |R₆〉 of $\mathcal{R}$.

Author contributions

L.GY. designed the protocol and wrote the manuscript. L.GY. and S.I. analyzed the results. All authors reviewed the manuscript.

Competing interests

The authors declare no competing interests.

Supplementary information

is available for this paper at 10.1038/s41598-020-67014-5.