Method of operating a quantum computing system for amplitude estimation

Abstract

The present disclosure relates to an improved method of operating a quantum computing system to perform amplitude estimation.SOLUTION: The method can be tuned to accommodate a particular noise level (e.g., within a given quantum device). The embodiments also enable the quantum computing system to perform amplitude estimation faster than amplitude estimation algorithms performed using classical (non-quantum) computers.SELECTED DRAWING: Figure 14D

Description

[Technical Field]

[0001] The present disclosure relates generally to methods of operating quantum computing systems, and more particularly to operating noisy, low-depth quantum computing systems and performing amplitude estimation. [Background technology]

[0002] This disclosure claims priority pursuant to 35 U.S.C. §119(e) to U.S. Provisional Patent Application No. 63 / 116,712, filed November 20, 2020, entitled "Algorithms for Quantum Amplitude Estimation With Noise," which is incorporated herein by reference in its entirety.

[0003] Quantum amplitude estimation algorithms aim to estimate the amplitude of unitary operators. These algorithms typically involve the implementation of large-scale quantum circuits. However, current quantum computers are noisy, qubit-limited, and have limited circuit depth (called noisy intermediate-scale quantum (NISQ) devices). Therefore, NISQ devices may not be capable of performing amplitude estimation. [Prior art documents] [Patent documents]

[0004] [Patent Document 1] U.S. Patent Application No. 15 / 446,973 [Non-patent literature]

[0005] [Non-Patent Document 1] Y. Suzuki, S. Uno, R. Raymond, T. Tanaka, T. Onodera, and N. Yamamoto, “Amplitude estimation without phase estimation,” Quantum Information Processing, vol. 19, no. 2, p. 75, 2020 [Non-patent document 2] D. Grinko, J. Gacon, C. Zoufal, and S. Woerner, “Iterative quantum amplitude estimation,” arXiv preprint arXiv:1912.05559, 2019 [Non-patent document 3] T. Tanaka, Y. Suzuki, S. Uno, R. Raymond, T. Onodera, and N. Yamamoto, “Amplitude estimation via maximum likelihood on noisy quantum computer,” arXiv preprint arXiv:2006.16223, 2020 Summary of the Invention

[0006] The embodiments described herein relate to enhanced methods of operating NISQ devices (and other quantum computing systems) to perform amplitude estimation. Not only that, the methods can be tailored to suit particular noise levels (e.g., in a given NISQ device). The embodiments may also enable NISQ devices to perform amplitude estimation faster than amplitude estimation algorithms implemented using classical (non-quantum) computers.

[0007] Some embodiments relate to two new low-depth methods for performing amplitude estimation (AE), which achieve a trade-off between quantum speedup and quantum circuit depth. For example, for β∈(0,1], the algorithm:

[0008]

number

[0009] To perform amplitude estimation within an additive error ε, we use the oracle call

[0010]

number

[0011] These methods interpolate between classical algorithms (β = 1) and standard quantum algorithms (β = 0), with a tradeoff ND = O(1 / ε 2 These methods bring quantum acceleration for Monte Carlo methods closer to reality because they can provide acceleration using shallower circuits.

[0012] The first method (Power Law AE) uses a power law schedule. The method works for β∈(0,1], and some embodiments have provable correctness if the log-likelihood function satisfies the regularity condition specified by the Bernstein-von Mises theorem.

[0013] The second method (QoPrime AE) uses the Chinese Remainder Theorem to combine lower depth estimates to achieve higher accuracy. This method works for discrete β=q / k, where k≧2 is the number of distinct relatively prime moduli used by the method, and 1≦q≦k−1. Some embodiments have a fully rigorous correctness proof.

[0014] Additionally, this disclosure analyzes both methods in the presence of depolarization noise and provides numerical comparisons with other amplitude estimation algorithms.

[0015] Other aspects include components, devices, systems, improvements, methods, processes, applications, non-transitory computer-readable media, and other techniques related to any of the above. [Brief explanation of the drawings]

[0016] Embodiments of the present disclosure have other advantages and features that will be more readily apparent from the following detailed description and the appended claims when taken in conjunction with the examples in the accompanying drawings.

[0017] [Figure 1] FIG. 10 is a plot of the log-likelihood function for the power-law amplitude estimation algorithm. [Figure 2] FIG. 10 illustrates a plot of convergence of a disjoint finding routine. [Figure 3] FIG. 20 illustrates a plot of the behavior of the oracle call dependency in Equation 21 for the Qoprime algorithm. [Figure 4] instantaneous index

[0018]

number

[0019] 1 illustrates a plot of the coherent to noise-dominant transition as measured by (k, q) where N is the number of oracle calls, optimized over the parameters k and q. [Figure 5] FIG. 10 illustrates a plot of the locus of optimal estimates for the k and q parameters. [Figure 6] Schedules for different error rates ε with values ​​β=0.455 and β=0.714

[0020]

number

[0021] 1 illustrates plots of theoretical (solid line) and actual (dots and triangles) performance of the power law algorithm using [Figure 7] FIG. 1 illustrates plots of theoretical (solid line) and actual (dots, triangles, and squares) performance of a power-law algorithm using a power-law schedule, where the parameter β is improved (e.g., optimized) for given ε and γ. [Figure 8] 1 illustrates plots of the performance of the QoPrime algorithm under several noise levels (γ). [Figure 9] FIG. 10 illustrates a plot of maximum oracle depth as a function of target precision ε. [Figure 10] FIG. 2 illustrates a plot of empirical values ​​for a constant prefactor C as described in equation (21). [Figure 11] FIG. 10 illustrates plots of the performance of the Power Law algorithm, the QoPrime algorithm, and the Iterative Quantum Amplitude Estimation (IQAE) algorithm at a noise level of γ=10 −3 . [Figure 12] 1 is a flowchart illustrating a first method of operating a quantum computer to determine θ of a unitary operator U within error ε. [Figure 13] 10 is a flowchart illustrating a second method of operating a quantum computer to determine θ of a unitary operator U within error ε. [Figure 14A] FIG. 1 is a block diagram illustrating an embodiment of a computing system. [Figure 14B] FIG. 1 is a block diagram illustrating an embodiment of a quantum computing system. [Figure 14C] FIG. 1 is a block diagram illustrating an embodiment of a quantum computing system. [Figure 14D] 1 is a flowchart illustrating an exemplary execution of a quantum routine on a computing system. [Figure 15]FIG. 1 is a diagram of an example architecture of a classical computing system. DETAILED DESCRIPTION OF THE INVENTION

[0022] The figures and the following description relate to preferred embodiments by way of example only. It should be noted that from the following discussion, alternative embodiments of the structures and methods disclosed herein will be readily recognized as viable alternatives that may be utilized without departing from the principles of the claims.

[0023] 1. Introduction Amplitude estimation (AE) describes a quantum algorithm that allows a quantum computing system to estimate the amplitude 〈0|U|0〉 for a quantum circuit U, up to an additive error ε. U is sometimes called a unitary operator. A unitary operator may (e.g., when executed by a quantum computing system) perform a unitary operation. The number of calls to U depends on the type of amplitude estimation algorithm. In some cases, the number of calls to U scales as O(1 / ε). Thus, these algorithms are generally faster than (O(1 / ε)). 2 ) offers a quadratic advantage over classical sampling and may have many applications, including acceleration for Monte Carlo methods and approximate counting.

[0024] In general, amplitude estimation is performed by U|0 t It involves a quantum circuit U applied to a register containing t qubits, such that |x〉 = cos(θ)|x,0〉 + sin(θ)|x',1〉, where |x〉 and |x'〉 are arbitrary states on the (t-1) qubit, and |0〉 and |1〉 are two possible states of the remaining qubit (which may be called the "final" qubit). More generally, U may affect more than one qubit, and the resulting states of interest may be called marked states. The goal is to estimate the amplitude θ within an additive error ε. A related approximate counting problem is

[0025]

number

[0026] is a uniform superposition (all amplitudes are the same) over a bit string of length (t-1), and the binary label on the final qubit is S ⊆ {0,1} t-1 corresponds to the special case of |S|, which is the indicator function when |S|. Amplitude estimation in this setting provides an estimate for |S|. Approximate counting now generalizes the problem of searching for globars and finding the number of marked elements in a list.

[0027] This disclosure discusses two applications of amplitude estimation: (1) to quantum Monte Carlo methods and (2) to dot-product estimation, which may be relevant to financial computing, optimization, machine learning, and linear algebra computing.

[0028] Quantum Monte Carlo is the application of amplitude estimation to the problem of estimating the mean of a real-valued random variable by sampling. Let f(x,S) be a real-valued function, where x is the input, S is a random seed, and σ is the variance of f(x,S). The additive error is up to the mean E S Classically estimating f(x,S) requires N=O(σ 2 / ε 2 ) samples. In contrast, quantum amplitude estimation requires

[0029]

number

[0030] can be used to estimate the mean using a sample of σ, thus improving the quadratic dependence on σ and 1 / ε. For example, in finance computations, an accuracy of ε=0.001 is often required, which implies that the number of samples can be reduced by a factor of 1000 when using quantum algorithms.

[0031] Amplitude estimation also has applications that are not reducible to approximate counting, for example, when the goal is to estimate 〈0|U|0〉 for a general unitary operator. Some examples of this kind include applications of amplitude estimation to quantum linear algebra and machine learning. For example, the vector

[0032]

number

[0033] A quantum procedure for estimating the dot product 〈x|y〉 between x and y can be useful for quantum classification and clustering algorithms. Amplitude estimation can be used to achieve quantum acceleration for this dot product estimation. For example, amplitude estimation can be performed in O(1 / ε 2 Instead of O(1 / ε) samples, we can use O(1 / ε) samples, which is the number of samples classically used to estimate the dot product to an error of ε. A variant of the amplitude estimation reduces the condition number dependence κ in linear system solvers to O(κ 2 ) to O(κ), which reduces the execution time and reduces the depth of the linear system solver quantum circuit by a factor of κ, and in many cases by a factor of 100 or more.

[0034] Some amplitude estimation algorithms (e.g., called standard amplitude estimation algorithms) call a controlled version of the quantum circuit U at least O(1 / ε) times in succession. A quantum Fourier transform is then performed to estimate the amplitude to an error of ε (e.g., using a phase estimation algorithm). This makes amplitude estimation applications such as Monte Carlo methods or approximate counting prohibitive for current hardware because, even in cases where the oracles themselves do not have significant depth, a large number of successive oracle calls makes the total depth of the circuit prohibitive for the high noise rates of current noisy intermediate-scale quantum (NISQ) devices. In summary, depending on the depth of the circuit U and the number of sequential executions, NISQ devices may be unable to execute amplitude estimation algorithms. Therefore, it may be advantageous to reduce the resources used for amplitude estimation algorithms so that they can be executed by NISQ devices.

[0035] Table 1 lists several amplitude estimation algorithms along with the resources used. Specifically, Table 1 illustrates the asymptotic tradeoffs for various amplitude estimation algorithms. In the table, n is the number of qubits, d is the circuit depth for a single application of U, ε is the additive error, β ∈ (0,1], k ≧ 2, and q ∈ [k−1]. An approximate counting algorithm is included for reference, but it requires additional structure and is not strictly an amplitude estimation algorithm.

[0036] [Table 1]

[0037] The power law and QoPrime algorithms are described in this disclosure. In contrast to the other algorithms in Table 1, these algorithms can be executed by NISQ devices. These algorithms solve the following questions: Quantum amplitude estimation algorithms use quantum circuits with depth less than O(1 / ε) (e.g., asymptotically) O(1 / ε) 2 The motivation for this work is whether it can provide some acceleration compared to classical algorithms (which scale as ∂ ... 2 ) applications, but these applications can be performed in parallel. On the other hand, standard quantum amplitude estimation algorithms use O(1 / ε) successive applications of oracles, but this calculation can be performed in one go. The present disclosure uses ND=O(1 / ε) 2 We present two new distinct algorithms that interpolate between classical and quantum settings using a trade-off of N, where N is the total number of oracle calls and D is the maximum number of sequential oracle calls that occur during any single execution of the quantum computing system.

[0038] As used herein, sequential or successive oracle calls refer to executing U multiple times "in quick succession" to generate a quantum state. This may be done by sequentially generating a quantum circuit that includes U multiple times. A quantum computing system may then be instructed to execute the circuit. The quantum state may then be measured. Power-law amplitude estimation algorithm

[0039] Our first algorithm utilizes the framework proposed by Suzuki et al. for quantum Fourier transform (QFT)-free amplitude estimation (see non-patent document 1). In Suzuki et al.'s framework, oracles are called at various depths, after which measurements in the standard basis are performed, followed by classical maximum likelihood postprocessing to estimate the amplitude. The algorithm in this framework follows the schedule (m k ,N k ), where the oracle is k For the iteration of m k times in succession, and finally the results are classically post-processed using maximum likelihood estimation.

[0040] Specifically, Suzuki always goes to depth m up to a maximum depth of O(1 / ε). k =2 k Use an exponential schedule with k =N shot describes a QFT-free amplitude estimation algorithm that selects . The quantum Fourier transform step at the end of the algorithm is eliminated. However, the asymptotic efficiency of the maximum likelihood postprocessing is not rigorously established.

[0041] The power law amplitude estimation algorithm (power law AE) of the present disclosure is k =N shot and,

[0042]

number

[0043] and k = 1, where k starts from 1 and β∈(0,1] (where "(" is exclusive, "]" is inclusive), the maximum depth for quantum circuits is O(1 / ε 1-β ), the total number of oracle calls is O(1 / ε 1+β), but at the cost of more parallel execution, which scales as . As β tends to 0, the schedule approaches an exponential schedule, while when β equals 1, the algorithm reduces to simply sampling directly from the oracle, similar to the case of sampling with a classical computer. The analysis of power-law amplitude estimation is based on the observation that maximum likelihood estimation in this setting is equivalent to subdividing the domain for amplitude θ into equal parts of O(1 / ε) and performing a Bayesian update starting from a uniform prior probability distribution with equal probability of every value being correct. In some embodiments, if the prior distribution and log-likelihood function (described later) are sufficiently regular, the Bernstein-von Mises theorem (also described later) can be used, which states that shot I f (α)), where α=cos 2 (θ), can be thought of as the Bayes Central Limit Theorem, which quantifies the rate of convergence of the Bayes estimate to a normal distribution centered on the true value of θ. A variant of the Bernstein-von Mises theorem can be useful in the analysis because it bounds the rate of convergence of the posterior distribution to a normal distribution in the l1 norm. The tradeoff ND=O(1 / ε 2 ) is obtained from the Fisher information calculation for power law schedules.

[0044] This disclosure also studies the behavior of the power law algorithm in the presence of (e.g., depolarization) noise and describes how to make the power law algorithm robust to noise. Indeed, this disclosure provides a method for selecting the (e.g., optimal) parameter β given a desired accuracy and noise level. The power law algorithm can be viewed as a (e.g., optimal or improved) way of exploiting the powers of available quantum circuits in terms of depth. In other words, (for Monte Carlo applications, 10 3 From 10 6Instead of waiting for the quantum circuit to have good enough fidelity to sequentially apply a large number of oracle calls on the order of 1 / ε (which can be between ε and ε), the power-law amplitude estimation algorithm can use quantum circuits of less depth (e.g., any depth offered by NISQ devices) and provide a corresponding acceleration.

[0045] Aspects of the analysis described above assume regularity conditions on the log-likelihood and prior distributions for the Bernstein-von Mises theorem. These regularity conditions can be difficult to verify, even though they appear to hold empirically for the log-likelihood function for amplitude estimation. Therefore, we can use the same ND = O(1 / ε) function that does not depend on these conditions. 2 ) trade-off. Therefore, we have determined a schedule that increases (e.g., maximizes) the Fisher information for a given number of oracle calls. The determined (e.g., optimal) solution may be a schedule that makes oracle calls at the maximum possible depth. However, making oracle calls only at a particular depth is a schedule that maximizes the function cos 2 Due to the periodicity of ((2k+1)θ), i.e., cos 2 This may not be sufficient for amplitude estimation because it may be difficult (or impossible) to distinguish between different values ​​of θ that result in the same value of ((2k+1)θ). This led us to consider amplitude estimation algorithms that run the circuit at two (or more) different depths and combine the results, leading to the QoPrime amplitude estimation algorithm. QoPrime amplitude estimation algorithm

[0046] Our second amplitude estimation algorithm (QoPrime AE) can enable sufficiently rigorous correctness proofs, with a similar or identical depth vs. number of oracle calls tradeoff (ND = O(1 / ε)) to power-law amplitude estimation for a set of exponents that take discrete values ​​between 0 and 1. 2 )) is used for amplitude estimation.

[0047] The idea behind the QoPrime amplitude estimation algorithm is that each 1 / k ), so that their product is N=O(1 / ε), where N is the total number of oracle calls. The true value of the amplitude θ can be defined to be πM / 2N, where M∈[0,N]. The algorithm is

[0048]

number

[0049] where N i is the N / N oracle followed by a measurement (e.g., in the standard basis) i These low accuracy estimates of the amplitudes are then

[0050]

number

[0051] are combined using the Chinese Remainder Theorem to obtain D, while the fractional (non-integer) part of M is estimated separately. As an example, the QoPrime algorithm is described for the simplest case with modulus k=2. This case is where D=O(1 / ε 1 / 2 ), N=O(1 / ε 3 / 2 ), where N is the total number of oracle calls and D is the maximum number of sequential oracle calls.

[0052]

number

[0053] For simplicity, let the truth value for θ be such that for some integer M∈[0,(2a+1)(2b+1)],

[0054]

number

[0055] Therefore, the QoPrime algorithm determines M mod (2a+1) and M mod (2b+1), and then uses the Chinese Remainder Theorem to determine M.

[0056] A successive call to the oracle followed by a measurement (e.g., in the standard base) returns cos 2 With a probability of success of ((2a+1)θ), this is equivalent to or similar to sampling from a Bernoulli random variable. As a function of θ, this probability is periodic, with a period

[0057]

number

[0058] and is therefore a function of ±M mod (2b+1). Subdividing the interval [0,π / 2] into equal parts of (2b+1) gives ±M mod (2b+1) in O((2b+1) 2 ) samples. This algorithm works in O(2b+1) time for a quantum circuit of depth (2a+1). 2 Using the iterations, we estimate M mod (2b+1), and similarly, we estimate O(2a+1) for a quantum circuit of depth (2b+1). 2 Iterations are used to estimate M mod (2a+1). These low accuracy estimates are then combined to obtain an integer M∈[0,(2a+1)(2b+1)], and as a result, the Chinese Remainder Theorem is used to improve the accuracy of the estimation procedure. The total number of oracle calls made is O(ab 2 +ba2 )=O(1 / ε 1.5 ) The maximum depth for an oracle call is O(1 / ε 1 / 2 ) The procedure is to find the true value for θ as

[0059]

number

[0060] where N is a product of relatively prime moduli with q≦k, and M∈[0,N], this can be extended to the more general case where M∈[0,N]. In this case, this disclosure also shows how to choose these values ​​q, k. Here, the maximum depth of a quantum circuit is D=O(1 / ε 1-q / k )), and the total number of oracle calls is N=O(1 / ε 1+q / k )

[0061] In addition, the accuracy of the algorithm in the presence of depolarization noise is considered. Specifically, this disclosure provides numerous graphs showing its behavior under noise. Analysis of the algorithm in a noisy setting shows that noise can limit the depth of oracle calls that can be made, but it also allows us to (e.g., optimally) select algorithm parameters to reduce (e.g., minimize) the number of oracle calls for a given target approximation error and noise rate. Experiments show that the constant overhead of the QoPrime algorithm is reasonable (C<10) for most settings of interest (described further below).

[0062] This disclosure also benchmarks two new low-depth amplitude estimation algorithms using the IQAE algorithm in noisy settings (Section 4.3). For reference, IQAE is described in [2]. Algorithms such as IQAE require access to the full circuit depth of O(1 / ε), and this large depth is exponentially penalized by depolarization noise by requiring an exponentially large number of executions of the quantum circuit to achieve accuracy below the noise level. In comparison, the power-law and QoPrime amplitude estimation algorithms transition smoothly to classical estimation scaling and do not suffer from an exponential increase in oracle calls. Following simulations for different error rates and noise levels, the power-law amplitude estimation algorithm shows the best practical performance.

[0063] Overall, this disclosure presents two low-depth algorithms for quantum amplitude estimation, thus potentially bringing numerous applications closer to the NISQ era. Specifically, the tradeoff between the total number of oracle calls and quantum circuit depth offered by these algorithms can be a powerful tool for finding quantum applications for near- and mid-term devices.

[0064] This disclosure is organized as follows: in Section 2, we describe and analyze the power-law amplitude estimation algorithm, while in Section 3, we describe and analyze the QoPrime amplitude estimation algorithm. In Section 4, we present empirical evidence of the performance of our algorithm and benchmark it with other state-of-the-art algorithms for amplitude estimation.

[0065] 2. Amplitude estimation using a power-law schedule 2.1 Preparation In this section, we introduce some preliminaries for the analysis of amplitude estimation using power-law schedules. Let X be a random variable with density function f(X,α) determined by a single unknown parameter α. Let l(X,α) = logf(X,α) be the logarithmic density function,

[0066]

number

[0067] In this section, all expectations are with respect to the density function f(X,α), and ' denotes the partial derivative with respect to α.

[0068] Fisher Information I f (α) is the variance of the log-likelihood function, i.e., I f (α)=Var[l'(X,α)], which is equivalent to I f (α)=-E f It can also be defined as [l"(X,α)]. More generally, the parameter

[0069]

number

[0070] Then the Fisher information is defined as the covariance matrix of the second partial derivative of l(X,α) with respect to α.

[0071] α * Let be the true value for α, and the distribution f(X,α * ) iid (independent and identically distributed) sample X i Consider the Bayesian setting where the prior distribution on α is updated given ,i∈[n]. The Bernstein-von Mises theorem (described below) states that for cases where the log-likelihood and prior distributions are sufficiently regular, the mean and variance in the l1 norm

[0072]

number

[0073] We quantify the rate of convergence of the Bayesian estimate to a normal distribution with . A complete list of regularity conditions for the theorem is given in Section 5.

[0074] Theorem 2.1 (Bernstein-von Mises Theorem): X i ,i∈[n] is the distribution f(X,α * ) and let R0 be the prior distribution on α. n Let be the posterior distribution after n samples,

[0075]

number

[0076] , the mean and variance

[0077]

number

[0078] Let the distribution be a Gaussian distribution with

[0079] f(X,α * ) and R0 satisfy the regularity conditions listed in Section 5,

[0080]

number

[0081] There exists a constant c>0 such that

[0082] As previously defined, the amplitude estimation algorithm is tAccess a quantum circuit U such that |x〉 = cos(θ)|x,0〉 + sin(θ)|x',1〉, where |x〉 and |x'〉 are arbitrary states on the (t-1) qubit. If the second register is measured (e.g., in the standard basis), the distribution of measurement outcomes f(X,α) is given by the probability of success α = cos 2 (θ)∈[0,1]. Thus, if a quantum computing system executes a circuit that includes k sequential calls to circuit U, the quantum state cos((2k+1)θ)|x,0〉+sin((2k+1)θ)|x',1〉 may be generated. Given this, measuring this generated state (e.g., in a standard basis) has a distribution of measurement outcomes with probability of success cos 2 It can be a Bernoulli random variable with ((2k+1)θ).

[0083] Therefore, the quantum amplitude estimation algorithm has a success probability of cos 2 We access samples from a Bernoulli random variable with ((2k+1)θ), where k is the number of sequential oracle calls in the quantum circuit, corresponding to its depth; samples with a higher depth (i.e., circuits with more sequential oracle calls) may be more informative for estimating θ. An example may help to illustrate this: 2 When sampling from a random variable with (3θ), we can obtain ε close to 3θ using O(1 / ε) samples, which means we obtain ε / 3 close to θ and therefore obtain better accuracy. The following proposition quantifies the benefit of sampling at a higher depth, and Fisher's information increases with the number m of sequential oracle calls. k It can be shown that it increases quadratically with

[0084] Proposition 2.2: f(X,α)=β X (1-β) 1-X where the parameter α=cos 2 (θ), a positive integer m k For β=cos 2 ((2mk +1)θ). The Fisher information is

[0085]

number

[0086] is.

[0087] Proof: α = cos 2 (θ), we obtain dα=2cos(θ)sin(θ)dθ. The log-likelihood function is l(X,α)=Xlogβ+(1-X)log(1-β). Therefore,

[0088]

number

[0089] The Fisher information is defined as a variance and is therefore additive over independent samples that do not necessarily follow the same distribution. k ,N k The Fisher information of a σ is the sum of the Fisher information for each individual sample.

[0090] 2.2 Power-law amplitude estimation algorithm An embodiment of an amplitude estimation algorithm using a power-law schedule is given below as Algorithm 2.1, which is then analyzed to establish the tradeoff between depth and total number of oracle calls in a setting where the Bernstein-von Mises theorem is applicable.

[0091] Algorithm 2.1 (Power-law amplitude estimation algorithm):

[0092] Goal: For a unitary gate U that implements U|0〉 = cos(θ)|x,0〉 + sin(θ)|x',1〉, and parameters β∈(0,1], N shot An estimate of θ to within accuracy ε (e.g., with high probability) for ∈Z.

[0093] Step 1: Angle

[0094]

number

[0095] Initialize the prior distribution to be a uniform distribution on

[0096] Step 2: For k=1 to

[0097]

number

[0098] do: a. Step 3:

[0099]

number

[0100] and

[0101]

number

[0102] and initialize it.

[0103] b. Step 4: For i=1 to N shots do: i. Step 5:

[0104]

number

[0105] , and measure the final qubit of the resulting quantum state (e.g., in the standard basis).

[0106] ii. Step 6: If the result is 0,

[0107]

number

[0108] otherwise,

[0109]

number

[0110] Let's say.

[0111] c. Step 7: end for.

[0112] d. Step 8: Bayesian update for θ = πtε / 2, where t ∈ [0, 1 / ε] is an integer value.

[0113]

number

[0114] and interpolate to obtain the posterior probability distribution.

[0115] Step 9: end for.

[0116] Step 10: Output the θ that has the (e.g., highest) probability according to the posterior probability distribution.

[0117] End of Algorithm 2.1.

[0118] The next theorem (below) shows that Algorithm 2.1

[0119]

number

[0120] and

[0121]

number

[0122] We show that we achieve an approximation error ε using, where D is the maximum number of sequential oracle calls (also called the maximum circuit depth) and N is the total number of oracle calls made.

[0123]

number

[0124] This choice leads to a power-law AE algorithm that makes at least log(1 / ε) oracle calls for small β, and as β → 0, it follows the exponential schedule m k =2 k approaching.

[0125] Theorem 2.3: The power law amplitude estimation algorithm 2.1 is

[0126]

number

[0127] oracle calls and the maximum circuit depth

[0128]

number

[0129] and produces an accurate estimate of ε with a probability of at least 0.9, i.e., the algorithm satisfies the trade-off in settings where the Bernstein-von Mises theorem is applicable.

[0130]

number

[0131] Achieve this.

[0132] Proof: The total number of oracle calls for Algorithm 2.1 is N = Σ k∈[K] N shot (2m k +1), while the Fisher information for the power law schedule is given by, using Proposition 2.2,

[0133]

number

[0134] (Replace the sum in the definition with the integral) N and I f Approximating the sum in (α) by the corresponding integral is I f (α)=O(K 1 / β ), N=O(K (1+β) / 2β ), and maximum depth D = O(K (1-β) / 2β ), so I f (α)=O(ND).

[0135]

number

[0136] If

[0137]

number

[0138]

number

[0139]

number

[0140] Note that we obtain

[0141] Next, we show that with probability at least 0.9, the estimate output by the algorithm is within an additive error ε of the true value. Applying the Bernstein-von Mises theorem, we can find the posterior distribution and the mean and variance

[0142]

number

[0143] The l1 distance between the Gaussian distribution with

[0144]

number

[0145] With a probability of at most

[0146]

number

[0147] is.

[0148] When δ=0.05,

[0149]

number

[0150] If we select , the estimate will be at least 1-δ(1+1)-0.0013 ≥ 0.89 with a probability of

[0151]

number

[0152] The probability of success is within ζ > 0, by running the power law algorithm O(log(1 / ζ)) times and outputting the most frequent estimate.

[0153]

number

[0154] can be raised to

[0155] The above proof analyzes Algorithm 2.1 in a setting where the Bernstein-von Mises theorem is applicable. A complete list of regularity conditions for the theorem is enumerated in Section 5. At a high level, for some neighborhood around real values ​​of θ, the regularity conditions impose the smoothness of the prior distribution and the smoothness of the density function f(X,θ), which is satisfied if the norm of the log-likelihood is bounded around θ, and the smoothness and differentiability of the Fisher information around θ, which holds if the log-likelihood function has at least third derivatives.

[0156] Figure 1 plots the log-likelihood function for a power-law AE algorithm for a fixed exponent β and varying depth (k) versus the true value for θ chosen uniformly randomly from [0,π / 2]. The figure illustrates that the log-likelihood function is smooth in a neighborhood around the true value of θ, indicating that the regularity condition of the Bernstein-von Mises theorem may be plausible in this setting. Adding noise may further regularize the log-likelihood function and strengthen the regularity condition for the Bernstein-von Mises theorem.

[0157] The constants c and c' in the proof of Theorem 2.3 are N shot can be determined explicitly if the regularity condition is verified by giving an explicit value for N. In the absence of an explicit value, experimental results shot If it shows convergence for small values ​​of N shot This may be taken as evidence that is a reasonably small constant.

[0158] 2.3 Power-law amplitude estimation in the presence of noise Noise provides a natural constraint on the accessible circuit depth, and the noise model exponentially penalizes greater depth, leading to exponential decoherence of the quantum state. Thus, exponentially more classical samples may be required to combat the noisy information (depending on the algorithm). In this section, we demonstrate this effect for power-law algorithms in the case of a depolarizing noise model.

[0159] Proposition 2.4: Assuming a depolarized noise channel with a rate per oracle call of γ ≥ 0, if a measurement (e.g., in a standard basis) is performed on a quantum circuit making k sequential calls to an oracle U, the distribution of measurement outcomes is

[0160]

number

[0161] is a Bernoulli random variable with

[0162] {m k} k=0,...,K Let be the schedule. The Fisher information in the presence of depolarization noise with parameter γ is

[0163]

number

[0164] For more information, see Non-Patent Document 3. α=cos 2 Recall that (θ) is the probability of success without depolarization noise. k becomes large enough so that the term

[0165]

number

[0166] For k such that is very close to zero, the second term in the sum is exponentially damped. Thus, the Fisher information does not increase significantly as the circuit depth increases (i.e., as the number of sequential oracle calls increases).

[0167] As explained in Algorithm 2.1,

[0168]

number

[0169] and β∈(0,1],

[0170]

number

[0171] Consider a power-law schedule given by , k=0,1,...,K.

[0172]

number

[0173] Here, C is

[0174]

number

[0175] (If it diverges, add a small random noise to θ). So, by the Cramer-Rao bound,

[0176]

number

[0177] where c:=C' -1 / 2 This means that for a given noise level γ, increasing the depth for a power-law schedule with fixed parameter β reduces cγ 1 / (1-β) This implies that it is not possible to obtain an error rate ε smaller than . In other words, given a desired error rate ε and a noise level γ, the parameter β can be determined to meet the lower bound in Equation 4. In this case, it is assumed that the Bernstein-von Mises regularity condition also holds in the noisy setting, so that the lower bound can be met on ε.

[0178] If the noise level is less than the desired error rate, then an exponential schedule (for β equal to 0) can be used, since circuits up to O(1 / ε) deep can be applied. For ε<γ, assume that β can be matched to the lower bound in Equation 4, so that it can be determined as follows:

[0179] Proposition 2.5: Assume a target error ε and noise level γ such that 0<ε<γ<1, and assume that the Bernstein-von Mises regularity condition holds in the presence of noise. The parameter β of the power law algorithm is given by the parameter

[0180]

number

[0181] A power law schedule with

[0182]

number

[0183] , k=0,1,...,K, (with high probability over the randomness of the algorithm, as discussed above) ε≦cγ 1 / (1-β) To achieve this,

[0184]

number

[0185] It can be determined according to:

[0186] 3. QoPrime: Number-theoretic amplitude estimation algorithm 3.1 Preparation This section introduces the technical tools used for the QoPrimeAE algorithm. In particular, this section describes the Chinese Remainder Theorem and the additive form of the Chernoff bound.

[0187] Theorem 3.1 (Chinese Remainder Theorem):

[0188]

number

[0189] , i∈[0,k], for all i≠j, gcd(a i ,a j )=1, and N=Π i∈[k] a i Then, for all b i ∈[a i ],i∈[k],M mod a i =b i There exists a polynomial-time algorithm for finding M∈[N] such that

[0190] Proof: We first explain the proof for k=2. By applying the extended Euclidean algorithm, 1=gcd(a1,a2)=u1a1+u2a2, (5) It seems like

[0191]

number

[0192] Then, M=(b2u1a1+b1u2a2) mod a1a2 is M=b for i=1, 2. i mod a i Meet the following.

[0193] For the proof in the general case, consider the k-1 numbers a1, a2, a3, a4, . . ., a k are relatively prime, and by the above discussion, the constraint M=b i mod a i Note that is equivalent to M=(b2u1a1+b1u2a2) mod a1a2. Therefore, the procedure can be repeated iteratively to find the desired M. End of proof for Theorem 3.1.

[0194] The QoPrime algorithm in this disclosure uses relatively prime modulo a i However, the result is a i can be adapted to the setting where N is pairwise non-prime. For example, this can be i∈[k] a i a i This can be done by replacing

[0195] Another tool used for the QoPrime algorithm is the additive form of the Chernoff bound and some complementary calculations on the entropy of the binomial distribution.

[0196] Theorem 3.2 (Chernoff-Höffding bound): Let i∈[m] be a function of X i The expected value

[0197]

number

[0198] X with i Let be an iid random variable, ∈{0,1}, with ε>0, and

[0199]

number

[0200] At that time, 1.Pr[X>p+ε]≦e -D(p+ε||p)m 2.Pr[X <p-ε]≦e -D(p-ε||p)m where the relative entropy

[0201]

number

[0202] and the relative entropy is given by the inequality for all x,y∈[0,1]

[0203]

number

[0204] can be used to define a lower bound.

[0205] A lower bound on the relative entropy can be used to validate the Chernoff bound.

[0206] We then derive a system that may be useful for analyzing the QoPrime algorithm.

[0207] Corollary 3.3: The following lower bound holds for the relative entropy for all x,y∈[0,1].

[0208]

number

[0209] Proof: The relative entropy is symmetric under the permutation (x,y) → (1-x,1-y), i.e., D(x||y) = D((1-x)||(1-y)). For (x',y') = (1-x,1-y), the inequality

[0210]

number

[0211] By applying, the result is obtained. End of proof.

[0212] This disclosure also provides multiplicative Chernoff bounds that may be used to calculate one or more constants in the QoPrime algorithm.

[0213] Theorem 3.4 (Multiplicative Chernoff Bound): Let i∈[m] be X i , X i Let X = Σ be independent random variables ∈[0,1]. i∈[m] X i Then, for 0<β<1,

[0214]

number

[0215] is.

[0216] 3.2 QoPrime AE Algorithm An embodiment of the QoPrime AE algorithm is presented as Algorithm 3.1. The implementation of the algorithm steps is described in more detail below, and the algorithm is analyzed to establish correctness and bound execution time.

[0217] The amplitude estimation algorithm is U|0 t Recall that we have access to a quantum circuit U such that |x〉 = cos(θ)|x,0〉 + sin(θ)|x',1〉, where |x〉 and |x'〉 are arbitrary states on the (t-1) qubit. Let R0 be the |0 t 〉, i.e., R0|0 t 〉=|0 t 〉, and R0|0 ⊥ 〉=-|0 ⊥〉 (where |0 ⊥ 〉 is |0 t 〉 state), and let S0 be the reflection on |0〉 in the second register, i.e., for all |x〉, S0|x,0〉 = |x,0〉 and S0|x,1〉 = -|x,1〉. The QoPrime algorithm uses (2k+1) sequential applications of the circuit on U to create the states.

[0218] |φ k 〉:=(UR0U -1 S0) k U|0〉=cos((2k+1)θ)|x,0〉+sin((2k+1)θ)|x',1〉 (6) As explained above, an oracle call is a single application (e.g., execution) of a circuit U on a quantum computing system, and the total number of oracle calls (N) is a measure of the execution time of the amplitude estimation algorithm on the quantum computing system. Also, the maximum circuit depth (D) is the maximum number of sequential calls to U in a single execution of the quantum computing system. As mentioned above, (2k+1) sequential oracle calls are required to generate a quantum state |φ k 〉 to create a copy.

[0219] Some embodiments of the QoPrime algorithm are parameterized by integers (k, q), where k ≥ 2 and 1 ≤ q ≤ (k-1). The parameter k is the number of moduli used for the reconstruction procedure, and q determines the number of moduli grouped together. The algorithm works by using a set of relatively prime moduli (n1, n2, ..., n k ), where each modulus is determined by:

[0220]

number

[0221] is an integer close to

[0222]

number

[0223] of,

[0224]

number

[0225] where M∈[0,N] and N=Π i∈[k] n i The algorithm divides the set of moduli of k into groups π of size at most q. i This includes dividing the

[0226]

number

[0227] Let's say

[0228]

number

[0229] Let be the product of the moduli in each group.

[0230] Some embodiments of the QoPrime algorithm achieve, with high probability, M mod N i The estimate is within a (say, 0.5) confidence interval around

[0231]

number

[0232] These estimates are used to reconstruct the N / N i The quantum state can then be measured (e.g., in the standard basis). These low-precision estimates

[0233]

number

[0234] teeth,

[0235]

number

[0236] The Chinese Remainder Theorem can be used to determine an accurate estimate of ε for U. Some embodiments of the QoPrime algorithm use O(1 / ε) with respect to U to estimate θ within accuracy ε. 1-q / k ) sequential calls, totaling O(1 / ε 1+q / k ) oracle calls. Similar to the power-law algorithm, it trades off maximum circuit depth against the total number of oracle calls.

[0237] Algorithm 3.1 (QoPrime algorithm for amplitude estimation):

[0238] Target: U|0 t For a unitary gate U that implements 〉=cos(θ)|x,0〉+sin(θ)|x',1〉, and for parameters (k,q), k≧2 is the number of moduli and 1≦q≦(k-1), an estimate of θ to within accuracy ε with a probability of success of at least p, where 1-2ke for some constant c. -2c >p.

[0239] Step 1:

[0240]

number

[0241] The relatively prime odd moduli (n1,n2,...,n k ) and select N=Π i∈[k] ni and ensure that N≧π / ε.

[0242] Step 2: Let [k] be a set of k elements with size at most q.

[0243]

number

[0244] Group π i Divide into

[0245]

number

[0246] Let's say.

[0247] Step 3: If q / k≧1 / 3 then: a. Step 4: At least 1-e -2c With probability θ, the additive error

[0248]

number

[0249] To get an estimate, we use up to

[0250]

number

[0251] Uses depth 0 samples (depth 0 samples are sampled directly from the oracle).

[0252] Step 5: Else: a. Step 6: To obtain an additive error estimate for θ, use the accuracy ε' = O(1 / ε 1-q / k ), and

[0253]

number

[0254] Recursively call the QoPrime algorithm with q' / k' such that

[0255] Step 7: End if.

[0256] Step 8: For i=1 to

[0257]

number

[0258] do: a. Step 9: Quantum state

[0259]

number

[0260] (See Equation 6)

[0261]

number

[0262] Prepare a copy of and measure (e.g., in the standard basis) for each quantum state.

[0263] b. Step 10:

[0264]

number

[0265] Calculate where:

[0266]

number

[0267] is the probability of observing the outcome 0 for the predetermined qubit.

[0268] c. Step 11: M = tN i If set to +1

[0269]

number

[0270] Then, we define the additive error N / 2N calculated in steps 4 to 8 of the algorithm. i Determine t from the estimate. d. Step 12:

[0271]

number

[0272] Calculate where:

[0273]

number

[0274] is an estimate of M.

[0275] Step 13: end for.

[0276] Step 14: Interval

[0277]

number

[0278] Define α to be a number in

[0279] Step 15:

[0280]

number

[0281] Calculate where β i ∈[-0.25,0.25] is

[0282]

number

[0283] It is as if.

[0284] Step 16: Calculated M i Applying the Chinese Remainder Theorem to the value of

[0285]

number

[0286] Reconstruct.

[0287] Step 17: As an estimate for θ

[0288]

number

[0289] Determine.

[0290] End of Algorithm 3.1.

[0291] The procedure used in steps 4-12 of QoPrime Algorithm 3.1 is described next, and correctness proofs are provided for each step.

[0292]

number

[0293] , 0≦l≦N i For M=tNi +l, where l=M mod N i Note that is the value estimated in step 5 of the QoPrime algorithm.

[0294] Step 9 of QoPrime Algorithm 3.1 is the success probability

[0295]

number

[0296] Step 10 samples from a Bernoulli random variable with the estimate

[0297]

number

[0298] Calculate where:

[0299]

number

[0300] is the observed probability of outcome 0. The following analysis shows that, with high probability,

[0301]

number

[0302] This indicates that

[0303] We,

[0304]

number

[0305] If

[0306]

number

[0307] (where p represents a real value,

[0308]

number

[0309] We start with the observation (where σ denotes the observed value).

[0310]

number

[0311] M=tN i Regarding +1,

[0312]

number

[0313] , the estimator in step 10 is (-1) as shown in Lemma 3.6 (below). t l mod N i However, the Chinese Remainder Theorem-based reconstruction procedure (step 16) estimates i For l mod N i In steps 3-7 of the algorithm, it is useful (e.g., necessary) to use (e.g., require) the estimate M=tN i +Additive error N for l i / 2 is determined by recursively using the QoPrime algorithm. Then, the value of t is determined such that 0≦t <N / N i As tN i +N i This is determined in step 11 by rounding the estimate to the nearest integer of the form / 2. The following lemma establishes the correctness of this recursive procedure.

[0314] Lemma 3.5: The recursive procedure in steps 3–7 of the QoPrime algorithm completes in at most O(logk) iterations and is at least 1-9e -2c With probability, the additive error estimate N i Outputs / 2N.

[0315] Proof: First, we establish the correctness of the stopping condition in step 4. If q / k ≥ 1 / 3, then

[0316]

number

[0317] Therefore, by the multiplicative Chernoff bound, the additive error with respect to θ is

[0318]

number

[0319] The estimate is

[0320]

number

[0321] Using depth 0 samples, we set a constant c>0 and -2c It is acquired with a probability of

[0322] Then, the recursion completes in at most O(logk) steps, and the total number of oracle calls used in the recursive steps is O(1 / ε 1+q / k ) indicates that an upper limit can be set.

[0323] The recursive call to the QoPrime algorithm in step 6 is O(1 / ε' (1+q’ / k’) )=O(1 / ε (1-q / k))(1+q’ / k’)) total oracle calls. Since (1-q / k)(1+q' / k')<(1+q / k), the total number of oracle calls used by steps 3-7 is at most O(1 / ε 1+q / k ) The additional oracle calls used for these steps cannot change the asymptotic number of oracle calls used by the QoPrime algorithm. Furthermore, since 1 + q / k < 1 + 2q / k < (1 + q / k) / (1 - q / k), it is possible to choose q' = 2q, k' = k, and with this choice, the stopping condition in step 4, q / k ≥ 1 / 3, holds after a large number of iterations (e.g., at most O(logk) iterations).

[0324] The probability of success for these steps is at most

[0325]

number

[0326] The probability of success is similar to (e.g., the same as) the probability of success for the final recursive call to the Qo-prime algorithm in step 6, which uses a modulus of . For this final recursive call, the probability is at least 1-3e due to the union bound. -2c Furthermore, the argument in Theorem 3.7 shows that in the setting where t is correctly determined and there are at most three moduli, the QoPrime algorithm has a probability of at least 1-6e -2c probability of success, and steps 3 to 7 are at least 1-9e -2c This shows that the probability of success is implied. End of the proof of Lemma 3.5.

[0327] The following lemma is

[0328]

number

[0329] Using the Chernoff bound to limit the difference between and p, (-1) t l mod N i Quantify the error that may occur in approximating

[0330] Lemma 3.6: For modulus N, m = 100cN 2 Given a sample of , steps 9-10 of the QoPrime algorithm should be at least 1-2e -2c With probability,

[0331]

number

[0332] Find an estimate such that

[0333] Proof: By Equation 7, F(p)=(-1) t l mod N, and

[0334]

number

[0335] So, change F:[0,1]→[0,N] as follows:

[0336]

number

[0337] For all p∈[0,1],

[0338]

number

[0339] It is sufficient to show that

[0340]

number

[0341] The inverse function G:[0,N]→[0,1] such that F(p)=y is monotonically decreasing.

[0342]

number

[0343] teeth,

[0344]

number

[0345] is equivalent to, i.e.,

[0346]

number

[0347] Applying the additive Chernoff bound

[0348]

number

[0349] The analysis divides into two cases where the relative entropy is lower bounded using the inequality in Theorem 3.2 or using the inequality in Corollary 3.3.

[0350]

number

[0351] and

[0352]

number

[0353] Let's do this. First, consider the case where y > N / 2, or equivalently, the case where A > π / 4.

[0354]

Number

[0355] Regarding the last two steps in the calculation, note that the inequality (sin(A) + cos(A)Tan(B)) 2 > 1, and

[0356]

Number

[0357] is used together with the lower bound sin(x) ≥ x / 2 for x ∈ [0, π / 2].

[0358] For the case where y < N / 2, a similar calculation is performed using Equation 3.3 to determine the lower bound of the relative entropy.

[0359]

Number

[0360] Regarding the last step in the calculation, the inequality (cos(B) + sin(B)cot(A)) 2 > 1, and

[0361]

Number

[0362] is used together with the lower bound sin(x) > x / 2 for x ∈ [0, π / 2].

[0363] Similarly,

[0364]

Number

[0365] teeth,

[0366]

number

[0367] and the probability can be bounded using the additive Chernoff bound.

[0368]

number

[0369] Furthermore, at least 1-e -2c With probability mD(G(y+0.25)||G(y))≧2c for all y∈[0,N]. This is because the denominator (cos 2 (B), sin 2 (A)) to (cos 2 (A), sin 2 (B)) from calculations similar to those in Equations 9 and 10. From the union bound in probability theory, -2c With probability,

[0370]

number

[0371] We obtain that. End of proof for Lemma 3.6.

[0372] The value M used later in the Chinese Remainder Theorem i The procedure in steps 14-16 of QoPrime Algorithm 3.1 to estimate , will now be described. The estimates produced by the QoPrime algorithm

[0373]

number

[0374] The corresponding confidence interval

[0375]

number

[0376] Define I=∩ i A i A i Applying the union bound and Lemma 3.6, I is nonempty and has at least 1-2 ke -c It follows that with probability β ∈ I, the fractional part {M}∈I. Therefore, step 14 of the QoPrime algorithm can determine α∈I. In step 15, from α, β i ∈[-0.25,0.25],

[0377]

number

[0378] Then, the value M i but,

[0379]

number

[0380] We then show that using the Chinese Remainder Theorem on these values ​​will, with high probability, produce estimates with error ε.

[0381] Theorem 3.7: The estimates output by the QoPrime algorithm are at least 1-11ke -2c With probability , it is within the additive error ε of the true value.

[0382] Proof:

[0383]

number

[0384] Let CRT(m1,...,m k ) but m=m i mod N i (Note that CRT stands for Chinese Remainder Theorem.) The Chinese Remainder Theorem states that this function is invertible, specifically, that CRT -1 (m)=(m mod n1,...,m mod n k ) CRT functions are defined in the following sense: -1 (m+a)=(m+a mod n1,...,m+a mod n k ), or equivalently,

[0385]

number

[0386] For CRT(m1+a,m2+a,...,m k +a)=CRT(m1,...,m k )+a, it is continuous.

[0387]

number

[0388] In this case,

[0389]

number

[0390] The QoPrime algorithm outputs a reconstructed estimate instead.

[0391]

number

[0392] t is the β in step 15 of the QoPrime algorithm, according to Lemma 3.6. i Assuming that the choice of is correctly determined, for all i,

[0393]

number

[0394] where γ is at least 1-2 ke -2c and independent of i. This statement is sufficient for the analysis of Lemma 3.5, which shows that, in turn, t is indeed with probability 1-9e -2c The probability that the modulus and estimate are correct is 1-11ke by the union bound. -2c is.

[0395] The accuracy of the estimate for the modulus is

[0396]

number

[0397] By the continuity of the Chinese Remainder Theorem, the reconstruction error

[0398]

number

[0399] Therefore, the QoPrime algorithm

[0400]

number

[0401] and up to

[0402]

number

[0403] Different, estimated values

[0404]

number

[0405] Prints the result. End of the proof of Theorem 3.7.

[0406] 3.3 Parameter Selection This section provides further details on determining parameters for the QoPrime algorithm. The small ε asymptotics of the QoPrime algorithm are given by the product Θ(ε) of similarly sized relatively prime moduli and degrees. -1 ) and . To this end, we formulate the following lemma:

[0407] Lemma 3.8: For a fixed integer k ≥ 2,

[0408]

number

[0409] Given that,

[0410]

number

[0411] and

[0412]

number

[0413] k are mutually coprime integers n1(N) such that <n2(N)<···<nk (N) can be found.

[0414] This lemma follows from the sublinear scaling of the number of relatively prime numbers that can fit within an interval of a given size. In practice, a table of k-neighboring odd relatively prime numbers can be pre-computed. The calculated k-neighboring odd relatively prime numbers start at each odd integer and stop at sufficiently large values ​​of k and n1 according to the target precision ε. For both noise and noiseless cases, the approximation error ε=10 -10 To achieve this, k≦12 and

[0415]

number

[0416] Given a table, a target precision ε, and an integer k≧2, the implementation is

[0417]

number

[0418] From the table starting at

[0419]

number

[0420] Select the adjacent relatively prime numbers of k whose product is closest to . Figure 2 compares the table actually used with the theoretical guarantee in Lemma 3.8.

[0421] Specifically, Figure 2 illustrates a plot of the convergence of the disjointness finding routine described above. The output of the routine is the product N=n1...n k are k adjacent relatively prime numbers n1, n2, ..., n such that is close to π / ε. kThe smallest relatively prime number n1 (approaching 1 from below) and the largest relatively prime number n k (approaching 1 from above) coincides with the convergence in Lemma 3.8 for some values ​​of k, (π / ε) 1 / k It has been shown that it converges to

[0422] Therefore, the asymptotics of the noise-free QoPrime algorithm with respect to the parameters ε, k, q can be summarized as follows:

[0423] [Table 2]

[0424] The above analysis of the QoPrime algorithm shows that for a given target accuracy ε, and overall failure probability δ, the total number of oracle calls for some embodiments of the Qoprime algorithm is

[0425]

number

[0426] The constant C does not depend on the parameters of the algorithm. In fact, experimental results show that C is a small constant, and in practice we can expect C<10 (see, e.g., Figure 4).

[0427] In practice, given a target accuracy ε and a tolerable failure probability δ, improved (e.g., optimal) values ​​of k and q are determined such that the number of oracle calls in Equation 15 is reduced (e.g., minimized). For example, in this noise-free scenario, the preferred (e.g., optimal) parameter q is 1 (indicating that it is preferable to access the maximum allowable depth). Reducing (e.g., minimizing) the number of oracle calls in Equation 15 by selecting k is (ignoring the subleading contribution from the failure probability δ):

[0428]

number

[0429] results.

[0430] Putting this back into Equation 15 yields an asymptotic dependence of the oracle call on 1 / ε, up to a logarithmic factor, as expected in the quantum regime.

[0431]

number

[0432] 3.4 QoPrime Algorithm with Noise In this section, we study the performance of the QoPrime AE algorithm under the same depolarization noise model studied for the power-law AE algorithm. Inverting the noisy stochastic model described in Equation 2, θ becomes: 2nθ=±arccos[e γn (1-2p)] mod 2π (18) It can be calculated as follows:

[0433] As before, we use the confidence interval (e.g., ε ) for probability p calculated by (e.g., classical) post-processing of the measurement sample. p ) and ε θ This relationship can be used to convert to a confidence interval for the angle θ, which can be expressed as:

[0434]

number

[0435] The difference in the noisy case strengthens the angle confidence interval, e γnSince classical confidence intervals shrink as the square root of the number of samples, under this noise model the number of samples should be (e.g., to ensure noise-free confidence intervals) 2γn This provides a proof of the noisy version of Lemma 3.6.

[0436] Lemma 3.9: l∈[N i / 6,5N i / 6], where γ ≥ 0 is the depolarization noise rate per oracle call.

[0437]

number

[0438] Given a sample of , steps 4-5 of the QoPrime AE algorithm require at least 1-2e -c With probability,

[0439]

number

[0440] Determine an estimate such that

[0441] Similar to the noise-free algorithm (see (14)), we summarize the asymptotics of the noisy algorithm with respect to the parameters ε, k, q, γ as follows:

[0442] [Table 3]

[0443] Thus, for a given target accuracy ε, depolarization noise level γ, and overall failure probability δ, the total number of oracle calls is

[0444]

number

[0445] , where C is the same constant overhead as in Equation 15. Similar to the power-law AE algorithm, in practice, given a target accuracy ε, a noise level γ, and an acceptable failure probability δ, improved (e.g., optimal) values ​​of k and q can be determined such that the number of oracle calls in Equation 21 is reduced (e.g., minimized). See also Figure 3 for the behavior of the number of oracle calls for different values ​​of k and q.

[0446] More specifically, Figure 3 shows the results for several values ​​of the parameters k and q at a fixed noise level γ = 10 -5 and failure probability δ=10 -5 21 for the case where . When we obtain the minimum over the entire family of curves parameterized by all valid k and q (assumed to be continuous here for simplicity), we obtain the envelope of the improved (e.g., optimal) QoPrime algorithm (labeled "optimal over k, q"). This emerging behavior is consistent with the classical 1 / ε in the noise-dominated region ε<<γ. 2 scaling and the quantum scaling 1 / ε in the coherent regime ε>>γ.

[0447] In this way, decisions (e.g., optimization) on k and q are made in a time domain with a time constant of 1 / ε 2 This can yield an effective scaling of the oracle call as a function of ε that lies (e.g., always) between the classical scaling of ε and the quantum scaling 1 / ε (see Figure 4). Specifically, this can be formulated as a bound on the instantaneous exponent:

[0448]

number

[0449] Figure 4 shows the instantaneous index

[0450]

number

[0451] 1 illustrates a plot of the coherent to noise-dominant transition as measured by where N is the number of oracle calls, optimized over the parameters k and q.

[0452] In the noise-dominated limit, the improved (e.g., optimal) parameter q tends to its upper limit q = k - 1 (corresponding to the shallowest accessible circuit). Using this observation, we can analytically study the optimization over k using the dependence in Equation 21 and find that the improved (e.g., optimal) k parameter tends to (in successive approximations)

[0453]

number

[0454] It can be obtained that it can have the following form.

[0455] This allows us to analytically study the asymptotic dependence of the oracle calls on the target precision ε. Extracting the low ε bound

[0456]

number

[0457] where C is the constant prefactor introduced in Equation 21. This classical bound curve can be used to compare the asymptotic running time of the Qoprime algorithm with classical Monte Carlo techniques.

[0458] Outside the two noise limits, specifically the noise-dominant Equation 24 and the noise-free Equation 17, the improved (e.g., optimal) parameters k and q may be nontrivially problem-dependent, and they can be determined numerically. An exemplary (k, q) improved (optimal) trajectory obtained by optimizing Equation 21 is shown in FIG. 5.

[0459] Figure 5 shows the results for two different noise levels (γ = 10 -4 and γ=10 -8 21). For simplicity, the optimized estimates are on a continuous k, q scale. The green area marks the valid parameter region k ≥ 2, 1 ≤ q ≤ k-1. The arrows indicate the target accuracy ε for ε = 10 -3 From ε=10 -10 On the other hand, for ε<<γ (noise-free region), q=1.

[0460] 4. Empirical Results In this section, we present empirical results for the power-law and QoPrime AE algorithms and compare them with other amplitude estimation algorithms. The empirical results substantiate the theoretical analysis and provide further insight into the behavior of these low-depth algorithms in the noisy regime.

[0461] 4.1 Power Law AE Figure 6 compares the theoretical and empirically observed scaling of the number of oracle calls N as a function of the error rate ε for the power-law AE algorithm in the absence of noise, i.e., when γ = 0. We compare the scaling for a randomly chosen θ ∈ [0,π / 2] and for the parameter β ∈ {0.455, 0.714}, which is a fixed value that makes the exponents {0.2, 0.6}, respectively.

[0462]

number

[0463] We numerically simulate the power-law AE algorithm using [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,

[0464] More specifically, Figure 6 shows the schedules for different error rates ε, with values ​​β=0.455 and β=0.714.

[0465]

number

[0466] 1 illustrates plots of the theoretical (solid line) and actual (dots and triangles) performance of the power-law AE algorithm using θ * is randomly selected. N shot A number of shots were taken where ρ = 100. Applying linear regression to these experimental data points gives slopes of -1.718 and -1.469, while the theoretical slopes are -1.714 and -1.455 for the circle and triangle points, respectively.

[0467] Figure 7 shows the scaling of the power-law AE algorithm under several noise levels, where the parameter β is adaptively selected based on the error rate ε and the noise level γ. For target errors below the noise level, an exponential schedule can be used to obtain improved (optimal) quantum scaling. After this threshold, a power-law schedule is used, with the exponent chosen as in Proposition 2.5. The result is that for these smaller target errors, the scaling lies between improved (optimal) quantum scaling and classical scaling.

[0468] More specifically, Figure 7 illustrates plots of theoretical (solid line) and actual (dots, triangles, and squares) performance of a power-law AE algorithm using a power-law schedule, where the parameter β is improved (e.g., optimized) for a given ε and γ. For comparison, classical and quantum scaling are also plotted. For small target errors, improved (e.g., optimal) quantum scaling is obtained, while for smaller target errors, a power-law exponent is used, using Proposition 2.5. The result is that as the target error tends toward 0, scaling approaches classical scaling.

[0469] 4.2 QoPrime Algorithm The parameters k and q for the QoPrime algorithm can be determined to improve (e.g., optimize) beyond the Chernoff upper bound, obtained in Lemma 3.9 and described in Equation 20. Figure 8 shows the theoretical upper bound (solid line) and the empirically observed number of oracle calls (dots, triangles, and squares) as a function of accuracy ε for different noise rates (γ). The actual algorithm (dots, triangles, and squares) performs better than the theoretical bound (line) because it uses an exact binomial distribution to calculate confidence intervals, as opposed to the Chernoff bound in the theoretical analysis.

[0470] More specifically, Figure 8 illustrates plots of the performance of the QoPrime algorithm under several noise levels (γ). Both the theoretical upper bound (solid line) and the simulated oracle calls (dots, triangles, squares) are plotted for three scenarios: noise-free scenario (circles), depolarization rate γ = 10 -7 scenario (rectangle), and depolarization rate γ = 10 -5The classical Monte Carlo curve (dashed line) is obtained by assuming noiseless classical sampling from a constant oracle depth equal to 1. The curves are shown for a quantum ε for small errors ε>>γ. -1 Following scaling, when the precision is much smaller than the noise level (ε<<γ), it becomes the classical ε -2 It can be seen that the dependency shifts.

[0471] FIG. 9 plots the maximum oracle depth as a function of the target precision ε for the QoPrime algorithm in noiseless (γ=0) and noisy (γ≠0) settings, as well as for the IQAE algorithm.

[0472] More specifically, Figure 9 illustrates a plot of maximum oracle depth as a function of target precision ε. Both the noise-free QoPrime and IQAE algorithms achieve O(ε -1 ) has a depth scaling similar to that of the QoPrime algorithm. However, introducing a depolarization noise level γ provides a limit on the depth used by the QoPrime algorithm. Specifically, the plot suggests that the QoPrime algorithm of some embodiments generally cannot access circuit depths higher than the noise scale γ, which corresponds to an exponentially constrained confidence interval, and that the algorithm may require exponentially more samples to produce a good estimate.

[0473] Figure 10 provides empirical estimates for the constant coefficient C for the QoPrime algorithm in noisy settings. Observed values ​​of C are small constants, and simulations show that C<10 over a wide range of ε and noise rates that cover most settings of interest. More specifically, Figure 10 shows the empirical estimates for the QoPrime algorithm for any value of the true angle θ and failure probability δ=10. -5 2 illustrates a plot of the empirical value of the constant pre-factor C, as described in equation (21) above, over the target accuracy ε, where

[0474] 4.3 Benchmarks This section compares the performance of the power law and QoPrime AE algorithms against an amplitude estimation algorithm called IQAE (Iterative Quantum Amplitude Estimation Algorithm) and described in [2].

[0475] Figure 11 shows the results for γ=10 -3 The performance of the power-law, QoPrime, and IQAE algorithms is plotted for a noise level of . Performance is measured by the total number of oracle calls versus the target accuracy, ε. The plot highlights the superiority of the power-law and QoPrime algorithms over algorithms such as IQAE, which require access to a circuit with a depth of O(1 / ε). In this scenario, the large depth of the IQAE is exponentially penalized by the depolarization noise. Therefore, the IQAE requires an exponentially larger number of classical samples to achieve accuracy below the noise level. In comparison, the power-law and QoPrime AE algorithms smoothly transition to classical estimation scaling (i.e., they are nearly parallel to classical scaling) and do not suffer from an exponential increase in oracle calls. In these simulation results, the power-law AE algorithm has the best practical performance (because it uses fewer oracle calls than QoPrime).

[0476] 5. Regularity Conditions for the Bernstein-von Mises Theorem We enumerate the regularity conditions for the Bernstein-von Mises theorem (given in Section 2.1) for power-law schedules. k N times k Consider a schedule where, after each of the shots of, a measurement (in the standard basis) and a Bayesian update is performed.

[0477]

number

[0478] and

[0479]

number

[0480] is N k represents the number of times the outcomes 0 and 1 are observed in the measurement. The probability density function and log-likelihood are

[0481]

number

[0482] The regularity condition for the Bernstein-von Mises theorem states that for all possible values ​​of the measurement outcome X, for some integer s ≥ 2, there exists a suitable domain Θ such that the following statements hold:

[0483] Statement 1: f(X,θ) is continuous on Θ.

[0484] Statement 2: l(X,θ) is

[0485]

number

[0486] It is continuous above.

[0487] Statement 3: For any θ∈Θ, if σ,τ∈U, then E σ (l(X,τ) s ) is bounded. θ (More precisely, E σ (l(X,τ) s ) has a finite upper bound).

[0488] Statement 4: What

[0489]

number

[0490] For all σ∈U, the upper bound E σ |inf δ∈V l(X,δ)| s There exist neighborhoods U and V of θ, τ such that ≡(θ)≡(τ)≡(τ)≡(θ)≡(τ).

[0491] Statement 5: l(X,θ) is twice differentiable on Θ.

[0492] Statement 6: For all θ∈Θ, all τ∈U θ Regarding 0 <E τ [l”(X,τ) s ]<∞ (27) A neighborhood U such that θ There exists a s-th moment of the Fisher information.

[0493] Statement 7: For all θ, there exists a neighborhood U such that for all τ, σ∈U, ||l”(X,τ)-l”(X,σ)||≦||τ-σ||k θ (X) (28) A bounded function such that

[0494]

number

[0495] But it does exist.

[0496] Statement 8: The prior probability λ is positive on Θ,

[0497]

number

[0498] Above, it is 0.

[0499] Statement 9: For any θ∈Θ, for all σ, τ∈U θ , and the constant c θ > Regarding 0, |logλ(σ)-logλ(τ)|≦||σ-τ||c θ (29) A neighborhood U such that θ exists, which is equivalent to the continuity of λ' on Θ.

[0500] These regularity conditions above can be subdivided into three groups as follows:

[0501] Statements 1-4 concern the smoothness of f(X,θ) and l(X,θ), and they can be satisfied if the norm of the log-likelihood is bounded on Θ. We can choose Θ to be a subinterval around the true value where the log-likelihood is bounded.

[0502] Statements 5-7 are about the smoothness of the Fisher information over Θ. They assert that the Fisher information is bounded and differentiable over Θ, which means that the log-likelihood function should have at least a third derivative.

[0503] Statements 8-9 are about the smoothness of the prior distribution, i.e., the first derivative of the prior should be a continuous function. These are obviously true for a uniform distribution.

[0504] Referring back to Figure 1, the graph illustrates that the log-likelihood function is smooth over the neighborhood of the true value, and a large neighborhood Θ exists around the true value, indicating that the regularity condition for the Bernstein-von Mises theorem is valid in this setting. Algorithm 2.1 is stated with Θ being the entire interval [0,π / 2] because this choice seems to work in practice. One can also imagine a slightly modified algorithm in which the first few sampling rounds are used to obtain a rough estimate for the true value within the large interval Θ, and for subsequent rounds, the prior distribution is uniform over Θ and convergence is established using the Bernstein-von Mises theorem. Adding noise can further regularize the log-likelihood function and enforce the regularity condition of the Bernstein-von Mises theorem.

[0505] 6. Exemplary Methods 6.1 Exemplary Methods for Power Law Algorithms FIG. 12 illustrates a first method of operating a quantum computing system to determine θ of a unitary operator U within error ε, where U|0 t 12 is a flowchart illustrating a first method in which |x',1| = cos(θ)|x,0| + sin(θ)|x',1|, the method may be performed with a probability of success of at least p. The steps of the method may be performed in a different order, and the method may include different, additional, or fewer steps. The method is described as being performed by a computing system, including, for example, a classical computing system and a quantum computing system. The computing system may perform the operations of the method by executing instructions stored on a non-transitory computer-readable storage medium. The method in FIG. 12 may be considered an embodiment of a power law algorithm. For example, the steps may be similar to those in Algorithm 2.1.

[0506] The computing system (e.g., a classical computing system) determines 1205 a parameter β∈(0,1) (excluding 0 and 1). The parameter β determines the increase in circuit depth (where the circuit depth is m) for increasing values ​​of k (discussed further below). k The parameter β determines how fast the circuit depth (given by β) increases. Viewed another way, the parameter β determines the tradeoff between circuit depth and speedup. β may be determined based on noise in the computing system (e.g., a quantum computing system). In some embodiments, the parameter β may be determined using the techniques described in Section 4.

[0507] A computing system (e.g., a classical computing system) determines 1210 an initial probability distribution p(θ) for a set of angles θ. The initial distribution may be a prior probability distribution (called a prior distribution). A prior distribution is a probability distribution that reflects an initial estimate or guess before additional information is considered. In some embodiments, the distribution is

[0508]

number

[0509] This can be thought of as discretizing the possible angles (e.g., [0,π / 2]) into a number of bins (e.g., 1 / ε) of size πε / 2. The variable t can be an integer greater than zero (e.g., t∈[0,1 / ε]) that numbers the bins. t is a function of |0 t Note that this has nothing to do with the superscript t in 〉.

[0510] Steps 1215-1235 are executed in a loop for k=1 to K. Generally, K is selected to be as large as possible given the circuit depth capabilities of the quantum computing system. In some embodiments, K is

[0511]

number

[0512] This means that the value of K is

[0513]

number

[0514] and log(1 / ε). In these embodiments, this results in the method following an exponential schedule as β→0.

[0515] The computing system (e.g., a classical computing system) may, in 1215, k0 =0, N k1 Initialize to =0.

[0516] i=1 to N shots During this time, steps 1220 to 1230 are executed in a loop. shots is an integer that specifies the number of shots taken at each value of k. In other words, N shots is m k Specifies the number of samples taken at the circuit depth specified by N. shots may be determined during step 1205. If it is desired to reduce (e.g., minimize) the total number of oracle calls, then (N shot s affects the total number of oracle calls)N shots It may be desirable to reduce

[0517] The quantum computing system uses the unitary operator

[0518]

number

[0519] In other words, a quantum computing system executes a quantum circuit containing unitary operators sequentially.

[0520]

number

[0521] This creates a quantum state on the quantum computing system.

[0522] The quantum computing system measures the qubits of the resulting quantum state (e.g., in the standard basis) at 1225. The qubits may be final qubits (as described above). More generally, any marked state (e.g., corresponding to two or more qubits) may be measured. For example, the quantum computing system measures whether two qubits are both 0.

[0523] The computing system (e.g., a classical computing system) determines, at 1230, N k0 or N k1 Update the value of N k0 indicates the number of times a value of 0 was measured, and N k1 indicates the number of times a value of 1 is measured. For example, in response to a qubit having a value of 0, N k0 The value of N k0 +1 and in response to the qubit having a value of 1, N k1 The value of N k1 It will be updated to +1.

[0524] A computing system (e.g., a classical computing system) may, in 1235, k0 or N k1 The probability distribution is updated based on the updated value of . For example, the update is a Bayesian update. The Bayesian update is: for θ=πtε / 2, where t∈[0,1 / ε],

[0525]

number

[0526] The updated probability distribution may be referred to as the posterior probability distribution.

[0527] The computing system (e.g., a classical computing system) determines θ based on the updated probability distribution at 1240. In some embodiments, the determined value of θ corresponds to the highest probability in the posterior probability distribution. Thus, θ may be determined by determining which value of θ corresponds to the highest probability (e.g., within a threshold error) in the posterior probability distribution. In some embodiments, θ is determined within an error ε with a probability of at least 0.9.

[0528] In some embodiments, the total number of times U is executed on a quantum computing system to determine θ is O(1 / ε 1+β )

[0529] In some embodiments, the number of times a unitary operator U is executed sequentially in a single execution is

[0530]

number

[0531] In some embodiments, the number scales as

[0532]

number

[0533] The following is the result.

[0534] 6.2 Exemplary Method of QoPrime Law Algorithm FIG. 13 illustrates a second method of operating a quantum computing system to determine θ of a unitary operator U within error ε, where U|0 t 1 is a flowchart illustrating a second method where ∑ = cos(θ)|x,0∑ + sin(θ)|x',1∑. The method can be performed with a probability of success of at least p, where ∑ = 1-2ke for some constant c. -2c >p. The steps of the method may be performed in a different order, and the method may include different, additional, or fewer steps. The method is described as being performed by a computing system, including, for example, a classical computing system and a quantum computing system. The computing system may perform the operations of the method by executing instructions stored on a non-transitory computer-readable storage medium. The method in FIG. 13 may be considered an embodiment of the QoPrime algorithm. For example, the steps may be similar to those in Algorithm 3.1.

[0535] A computing system (e.g., a classical computing system) determines integer parameters k and q in 1305, where k≧2 and 1≦q≦(k−1). k specifies the number of moduli determined in step 1310. q specifies the number of moduli grouped together in step 1315. Parameters k and q may be determined using the techniques described in Section 4.

[0536] The computing system (e.g., a classical computing system) calculates 1310 the k relatively prime moduli (n1, n2,..., n k ) set N=Π i∈[k] n idescribes the product of relatively prime moduli in a set. The relatively prime moduli in a set can be determined such that N ≥ π / ε. Each modulus in the set is an integer. In addition, the relatively prime moduli can be odd. Alternatively, one of them can be even. The set of relatively prime moduli for k is

[0537]

number

[0538] For example, the set may be chosen to be close to 1 / ε 1 / k In some embodiments, the set of k relatively prime moduli is determined using the techniques described in Section 3.3.

[0539] The computing system (e.g., a classical computing system) may, at 1315, compute k relatively prime moduli (n1, n2,..., n k ) into a group π of size at most q [k / q] i Divide into.

[0540] In step 1320 (labeled "If Condition"), a computing system (e.g., a classical computing system) may perform the following operations: In response to q / k≧1 / 3, the computing system may calculate an additive error for θ (e.g.,

[0541]

number

[0542] ) estimate, we need to determine the number of depth 0 samples (e.g., greater than 0, at most

[0543]

number

[0544] ) is used. Depth 0 samples refer to executing a single oracle call (executing the circuit with a single instance of the unitary operator U). This is done with a threshold probability (e.g., at least 1-e -2c , where c is a constant). For more information, see step 4 of Algorithm 3.1.

[0545] In response to q / k<1 / 3, the computing system may recursively execute the method of FIG. 13 to obtain an additive error estimate for θ. For example, the method may be executed to accuracy ε′=O(1 / ε 1-q / k ), and

[0546]

number

[0547] For more information, see step 6 of Algorithm 3.1.

[0548] Steps 1325 to 1340 are executed in a loop for i=1 to [k / q].

[0549] Steps 1325 to 1335 are executed in a loop for a=1 to A. In some embodiments, the number of iterations, A, is

[0550]

number

[0551] where:

[0552]

number

[0553] As demonstrated in Lemma 3.6, this number of samples is found with probability 1-2e -2c is sufficient to get a good estimate. However, the number of instructions may be more or less.

[0554] The quantum computing system, in 1325, μ 〉=cos((2μ+1)θ)|x,0〉+sin((2μ+1)θ)|x',1〉,

[0555]

number

[0556] , which can be implemented by a quantum computing system that executes a program that includes the unitary operator U as a subroutine. For example, we can write the unitary operator U as (2((NN i ) / 2N i )+1) times sequentially,

[0557]

number

[0558] But will be prepared.

[0559] The quantum computing system, at 1330,

[0560]

number

[0561] (e.g., in the standard basis). For example, the quantum computing system measures all of the qubits involved. In another example, the quantum computing system measures only one or more qubits that correspond to the marked state.

[0562] A computing system (e.g., a classical computing system) records the measured quantum state at 1335.

[0563] The computing system (e.g., a classical computing system) may, at 1340, determine, based on the observed probability that the measurement of a particular qubit (which may be predetermined) is 0,

[0564]

number

[0565] More generally,

[0566]

number

[0567] is determined based on the observed probability of measuring 0 for the marked state, where a single qubit may be selected as the marked state.

[0568]

number

[0569] To determine

[0570]

number

[0571] determining a

[0572]

number

[0573] is the observed probability of outcome 0, and

[0574]

number

[0575] where t is

[0576]

number

[0577] Determine the sign of (t is |0 t (Note that this is unrelated to the superscript t in >), and determining

[0578]

number

[0579] To determine

[0580]

number

[0581] where β i ∈[-0.25,0.25] is

[0582]

number

[0583] and α is the interval

[0584]

number

[0585] Steps 10-12 of Algorithm 3.1 may provide more information.

[0586] A computing system (e.g., a classical computing system) may, in 1345:

[0587]

number

[0588] By applying the Chinese Remainder Theorem (e.g., Theorem 3.1) to the values ​​based on

[0589]

number

[0590] Build.

[0591] In 1350, the computing system (e.g., a classical computing system)

[0592]

number

[0593] For example, θ is determined based on the following:

[0594]

number

[0595] is determined by calculating

[0596] In some embodiments, the total number of times the unitary operator U is executed by the quantum computing system to determine θ is O(1 / ε 1+q / k )

[0597] In some embodiments, the number of times a unitary operator U is executed sequentially in a single execution is O(1 / ε 1-q / k ) In some embodiments, the number scales as O(1 / ε 1-q / k ) is as follows.

[0598] 7. Computing System Description FIG. 14A is a block diagram illustrating an embodiment of a computing system 1400. The computing system 1400 includes a classical computing system 1410 (also referred to as a non-quantum computing system) and a quantum computing system 1420. The classical computing system 1410 may control the quantum computing system 1420. An embodiment of the classical computing system 1410 is further described with respect to FIG. 15. Although the classical computing system 1410 and the quantum computing system 1420 are illustrated together, they may be physically separate systems (e.g., in a cloud architecture). In other embodiments, the computing system 1400 includes different or additional elements (e.g., multiple quantum computing systems 1420). Additionally, functionality may be distributed among the elements in a manner different from that described.

[0599] FIG. 14B is a block diagram illustrating an embodiment of a quantum computing system 1420. The quantum computing system 1420 includes any number of quantum bits (“qubits”) 1450 and an associated qubit controller 1440. As illustrated in FIG. 14C, the qubits 150 may reside in a qubit register of the quantum computing system 1420. Qubits are described further below. The qubit controller 1440 is a module that controls one or more qubits 1450. The qubit controller 1440 may include a classical processor such as a CPU, GPU, or FPGA. The qubit controller 1440 may perform physical operations on one or more qubits 1450 (e.g., it may perform quantum gate operations on the qubits 1440). 14B , a separate qubit controller 1440 is illustrated for each qubit 1450; however, qubit controller 1450 may control multiple (e.g., all) qubits 1450 in quantum computing system 1420, or multiple controllers 1450 may control a single qubit. For example, qubit controllers 1450 may be separate processors, parallel threads on the same processor, or some combination of both. In other embodiments, quantum computing system 1420 includes different or additional elements. Additionally, functionality may be distributed among elements in a manner different from that described.

[0600] 14D is a flowchart illustrating an exemplary execution of a quantum routine on a computing system 1400. A classical computing system 1410 generates 1460 a quantum program that is executed or processed by a quantum computing system 1420. The quantum program may include instructions or subroutines that are executed by the quantum computing system 1420. In an example, the quantum program is a quantum circuit. The program can be mathematically expressed in a quantum programming language or intermediate representation, such as QASM or Quil.

[0601] The quantum computing system 1420 executes the program at 1465 and calculates a result (called a shot or run) at 1470. Calculating a result may include performing a measurement of the quantum state produced by the quantum computing system 1420 resulting from executing the program. In practice, this may be performed by measuring one or more values ​​of the qubits 1450. The quantum computing system 1420 typically performs multiple shots to accumulate statistics from the stochastic run. The number of shots and the changes (e.g., parameter changes) that occur between shots may be referred to as a schedule. The schedule may be specified by the program. The result (or accumulated results) is recorded by the classical computing system 1410 at 1475. The result may be returned after a termination condition is met (e.g., a threshold number of shots has occurred).

[0602] FIG. 15 is an exemplary architecture of a classical computing system 1410, according to an embodiment. A quantum computing system 1420 may also have one or more of the components described with respect to FIG. 15. FIG. 15 shows a high-level block diagram illustrating the physical components of a computer system used as part or all of one or more entities described herein, according to an embodiment. The computer may have additional, fewer, or variations of the components provided in FIG. 15. While FIG. 15 shows a computer 1500, the diagram is intended as a functional description of various features that may be present in the computer system, rather than as an architectural diagram of the implementations described herein. In practice, as will be recognized by those skilled in the art, items shown separately may be combined and some items may be separated.

[0603] 15 illustrates at least one processor 1502 coupled to a chipset 1504. Also coupled to the chipset 1504 are memory 1506, a storage device 1508, a keyboard 1510, a graphics adapter 1512, a pointing device 1514, and a network adapter 1516. A display 1518 is coupled to the graphics adapter 1512. In one embodiment, the functionality of the chipset 1504 is provided by a memory controller hub 1520 and an I / O hub 1522. In another embodiment, the memory 1506 is coupled directly to the processor 1502 instead of the chipset 1504. In some embodiments, the computer 1500 includes one or more communication buses for interconnecting these components. The one or more communication buses optionally include circuitry (sometimes referred to as a chipset) that interconnects and controls communication between the system components.

[0604] The storage device 1508 is any non-transitory computer-readable storage medium, such as a hard drive, a compact disk read-only memory (CD-ROM), a DVD, or a solid-state memory device or other optical storage, a magnetic cassette, a magnetic tape, a magnetic disk storage or other magnetic storage device, a magnetic disk storage device, an optical disk storage device, a flash memory device, or other non-volatile solid-state storage device. Such storage device 1508 may also be referred to as persistent memory. The pointing device 1514 may be a mouse, a trackball, or other type of pointing device and is used in combination with the keyboard 1510 to input data into the computer 1500. The graphics adapter 1512 displays images and other information on the display 1518. The network adapter 1516 couples the computer 1500 to a local or wide area network.

[0605] The memory 1506 holds instructions and data used by the processor 1502. The memory 1506 can be non-persistent memory, examples of which include high-speed random access memory such as DRAM, SRAM, DDR RAM, ROM, EEPROM, flash memory, etc.

[0606] As is known in the art, computer 1500 may have different components or other components than those shown in Figure 15. Additionally, computer 1500 may lack some of the illustrated components. In one embodiment, a computer 1500 functioning as a server may lack keyboard 1510, pointing device 1514, graphics adapter 1512, or display 1518. Additionally, storage device 1508 may be local to computer 1500 or remote (such as embodied in a storage area network (SAN)).

[0607] As is known in the art, the computer 1500 is adapted to execute computer program modules to provide the functionality described herein. As used herein, the term "module" refers to computer program logic utilized to provide a specified functionality. Thus, a module can be implemented in hardware, firmware, or software. In one embodiment, the program module is stored in the storage device 1508, loaded into the memory 1506, and executed by the processor 302.

[0608] Referring back to FIGS. 14A-14C , quantum computing systems utilize the laws of quantum mechanics to perform computations. A quantum processing device, a quantum computer, a quantum processor, and a quantum processing unit are each examples of a quantum computing system. A quantum computing system can be a general-purpose or non-general-purpose quantum processing device (a general-purpose quantum device can implement any possible quantum circuit (subject to the constraint that the circuit does not use more qubits than the quantum device possesses)). Quantum processing devices typically use so-called qubits, or quantum bits. While classical bits always have a value of either 0 or 1, a qubit is a quantum mechanical system that can have the value 0, the value 1, or a superposition of both values. Exemplary physical implementations of a qubit include superconducting qubits, spin qubits, trapped ions, arrays of neutral atoms, and photonic systems (e.g., photons in a waveguide). For purposes of this disclosure, a qubit may be realized by a single physical qubit or as an error-protected logical qubit that itself includes multiple physical qubits. This disclosure is also not specific to qubits: it can be generalized to apply to quantum processors whose building blocks are qubits (d-level quantum systems, where d>2), or quantum continuous variables rather than qubits.

[0609] A quantum circuit is an ordered collection of one or more gates. A subcircuit may refer to a circuit that is part of a larger circuit. A gate represents a unitary operation performed on one or more qubits. Quantum gates may be described using unitary matrices. The depth of a quantum circuit is the minimum number of steps required to execute the circuit on a quantum computer. Because gates that operate on non-overlapping subsets of qubits can be executed in parallel, the depth of a quantum circuit may be less than the total number of gates. A layer of a quantum circuit may refer to a step of the circuit between which multiple gates can be executed in parallel. In some embodiments, a quantum circuit is executed by a quantum computing system. In this sense, a quantum circuit can be considered to include a set of instructions or operations that a quantum computing system can execute. To execute a quantum circuit on a quantum computing system, a user can inform the quantum computing system which circuit to execute. A quantum computing system may include both a core quantum device and classical peripheral / control devices (e.g., qubit controllers) used to coordinate the control of the quantum device. It is to this classical control device that a description of the quantum circuit can be sent when one wants to have the quantum computer execute the circuit.

[0610] A variational quantum circuit refers to a parameterized quantum circuit that can be executed multiple times, each time changing some of the parameter values. The parameters of a parameterized quantum circuit may refer to the parameters of a gate unitary matrix. For example, a gate that performs a rotation about the y-axis may be parameterized by a real number that describes the angle of rotation. Variational quantum algorithms are a class of hybrid quantum-classical algorithms in which a classical computer is used to select and change the parameters of a variational quantum circuit. Typically, the classical processor updates the variational parameters based on the results of measurements of previous executions of the parameterized circuit.

[0611] Descriptions of quantum circuits executed on one or more quantum computers may be stored on a non-transitory computer-readable storage medium. The term "computer-readable storage medium" should be interpreted to include a single medium or multiple media capable of storing instructions (e.g., a centralized or distributed database, or associated caches and servers). The term "computer-readable medium" should also be interpreted to include any medium capable of storing instructions that can be executed by a quantum computer and cause the quantum computer to perform any one or more of the methods disclosed herein. The term "computer-readable medium" includes, but is not limited to, data repositories in the form of solid-state memory, optical media, and magnetic media.

[0612] The approaches described above may be suitable for cloud quantum computing systems in which quantum computing is provided as a shared service to separate users. An example is described in U.S. Patent Application Publication No. 2009 / 0129990, entitled "Quantum Computing as a Service," which is incorporated herein by reference.

[0613] 8. Additional Considerations The foregoing disclosure has described exemplary embodiments for purposes of illustration only, and any features described as essential, critical, or otherwise implied as essential should be construed as essential for that embodiment only, and not necessarily present in other embodiments.

[0614] Additionally, the above disclosure often uses the phrase "we" (and other similar phrases) to refer to entities performing operations (e.g., steps in an algorithm). These phrases are used for convenience. These phrases may refer to computing systems (including, e.g., classical computing systems and quantum computing systems) that are performing the operations described.

[0615] Some portions of the above description describe embodiments in terms of algorithmic processes or operations. These algorithmic descriptions and representations are commonly used by those skilled in the computing arts to effectively convey the substance of their work to others skilled in the art. While these operations are described functionally, computationally, or logically, it will be understood that they are implemented by computer programs, including instructions for execution by a processor or equivalent electrical circuitry or microcode, etc. Further, it has proven convenient at times, without loss of generality, to refer to these arrangements of functional operations as modules. In some cases, modules may be implemented in hardware, firmware, or software.

[0616] As used herein, any reference to "one embodiment" or "an embodiment" means that a particular element, feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment. The appearances of the phrase "in one embodiment" in various places in this specification do not necessarily all refer to the same embodiment. Similarly, the use of "a" or "an" preceding an element or component is done for convenience only. This description should be understood to mean that one or more of the element or component are present, unless it is clear that something else is meant. As used herein, the terms "comprises," "comprising," "includes," "including," "has," "having," or any other variation thereof, are intended to cover a non-exclusive inclusion. For example, a process, method, article, or apparatus that includes a list of elements is not necessarily limited to only those elements and may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Furthermore, unless expressly stated to the contrary, "or" refers to an inclusive or, not an exclusive or. For example, a condition A or B is satisfied by any one of the following: A is true (or exists) and B is false (or does not exist), A is false (or does not exist) and B is true (or exists), and both A and B are true (or exist).

[0617] Additionally, the use of "a" or "an" is utilized to describe elements and components of an embodiment. This is done merely for convenience and to give a general sense of the disclosure. This description should be read as including one or at least one, and the singular also includes the plural unless it is clear that something else is meant. When values ​​are described as being "approximately" or "substantially" (or derivatives thereof), such values ​​should be construed as being accurate to ±10% unless otherwise clear from the context. From the example, "approximately 10" should be understood to mean "in the range of 9 to 11."

[0618] Alternative embodiments may be implemented in computer hardware, firmware, software, and / or combinations thereof. Implementations may be implemented in a computer program product tangibly embodied in a machine-readable storage device for execution by a programmable processor, with method steps being performed by the programmable processor executing a program of instructions to perform functions by manipulating input data and generating output. As used herein, "processor" may refer to one or more processors. Embodiments may advantageously be implemented in one or more computer programs executable on a programmable system including at least one programmable processor coupled to receive data and instructions from, and send data and instructions to, a data storage system, at least one input device, and at least one output device. Each computer program may be implemented in a high-level procedural or object-oriented programming language, or in assembly or machine language, if desired; in either case, the language may be a compiled or interpreted language. Suitable processors include, by way of example, both general-purpose and special-purpose microprocessors. Generally, a processor receives instructions and data from read-only memory and / or random-access memory. A computer typically includes one or more mass storage devices for storing data files; such devices include magnetic disks, such as internal hard disks and removable disks, magneto-optical disks, and optical disks. Storage devices suitable for tangibly embodying computer program instructions and data include all forms of non-volatile memory, including, by way of example, semiconductor memory devices, such as EPROM, EEPROM, and flash memory devices, magnetic disks, such as internal hard disks and removable disks, magneto-optical disks, and CD-ROM disks.Any of the foregoing can be supplemented by, or incorporated in, ASICs (application-specific integrated circuits) and other forms of hardware.

[0619] While the above description contains many details, these should not be construed as limiting the scope of the invention, but merely as illustrating different examples. It should be understood that the scope of the present disclosure includes other embodiments not discussed in detail above. Various other modifications, changes, and variations apparent to those skilled in the art may be made in the arrangement, operation, and details of the methods and apparatus disclosed herein without departing from the spirit and scope of the invention.

Claims

1. A method for determining θ of a quantum unitary operator U within error ε, wherein U|0 t >=cos(θ)|x,0>+sin(θ)|x',1>, and the method comprises: determining a probability distribution p(θ) over a set of angles θ; The quantum unitary operator U is [Equation 1] instructing the quantum computer to execute the algorithm times sequentially, where β is a parameter β∈(0,1); instructing the quantum computer to measure the qubits of the resulting quantum state; performing a Bayesian update on the measured values ​​of the qubits; determining θ based on the updated probability distribution; A method comprising:

2. The total number of times the quantum unitary operator U is executed on the quantum computer to determine θ is O(1 / ε 1+β 2. The method of claim 1, wherein the metric scales as

3. The number of times the quantum unitary operator U is executed sequentially in a single execution is [Equation 2] The method of claim 1 , wherein the scaling factor is

4. Determining the probability distribution p(θ) for the set of angles θ comprises: angle [Equation 3] 2. The method of claim 1, comprising determining a uniform distribution over the set of t∈[0,1 / ε].

5. The method of claim 1 , wherein the determined θ based on the updated probability distribution corresponds to the highest probability in the updated probability distribution.

6. The method of claim 1 , wherein β is determined based on noise in the computing system.

7. 2. The method of claim 1, wherein θ is determined to be within error ε with a probability of at least 0.

9.

8. A method for determining θ of a quantum unitary operator U within error ε, wherein U|0 t >=cos(θ)|x,0>+sin(θ)|x',1>, and the method comprises: k's relatively prime modulus (n 1 , n 2 ,... ,n k ) and k's relatively prime modulus (n 1 , n 2 ,... ,n k ) into groups; During iteration i, |φ μ The quantum state defined by [Equation 4] instructing the quantum computer to execute the quantum unitary operator U to generate [Equation 5] an instructing step, The quantum computer [Equation 6] and instructing the measurement of determining θ based on the observed probability of measuring 0 for the qubit and applying the Chinese Remainder Theorem to the value; A method comprising:

9. The total number of times the quantum unitary operator U is executed on the quantum computer to determine θ is O(1 / ε 1+q / k 9. The method of claim 8, wherein q is an integer greater than or equal to 1.

10. The number of times the quantum unitary operator U is executed sequentially in a single execution is O(1 / ε 1-q / k 9. The method of claim 8, wherein q is an integer greater than or equal to 1. [Request Item 11] [Number 7] is that the quantum computer converts the quantum unitary operator U into (2((N-N i ) / 2N i 9. The method of claim 8, wherein the method is generated by sequentially executing the method a) + 1) times.

12. Said number of iterations is [Equation 8] 9. The method of claim 8, wherein c is a constant greater than 0.

13. θ is determined to be within error ε with probability at least p, where 1-2ke if the constant c is greater than 0. -2c The method of claim 8, wherein p is greater than 1.

14. A computer executable program comprising instructions which, when executed by a computer, cause the computer to carry out the method of any one of claims 1 to 13.

15. A computer readable storage medium comprising instructions which, when executed by a computer, cause the computer to perform the method of any one of claims 1 to 13.

16. a set of one or more processors; a computer readable storage medium storing instructions that, when executed by the set of one or more processors, cause the set of one or more processors to perform the method of any one of claims 1 to 13; A system comprising:

Images