A Quantum Approach to Subset-Sum and Similar Problems

07/27/2017 ∙ by Ammar Daskin, et al. ∙ 0

In this paper, we study the subset-sum problem by using a quantum heuristic approach similar to the verification circuit of quantum Arthur-Merlin games. Under described certain assumptions, we show that the exact solution of the subset sum problem my be obtained in polynomial time and the exponential speed-up over the classical algorithms may be possible. We give a numerical example and discuss the complexity of the approach and its further application to the knapsack problem.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

Subset-sum Kellerer et al. (2004) is a widely-studied NP-complete problem formally expressed as follows: Given a set of integer elements and a target value , determine if there is a subset, , of whose sum is equal to . In the associated optimization problem, the subset with the maximum sum less than is searched. The exact solution for this problem can be found by first computing the sum of elements for each possible and then selecting the maximum among those whose sum is less than . Clearly, this algorithm would take exponential-time in the number of elements. Another means to solve this problem is through dynamic programming which requires time. This is also exponential in the required number of bits to represent : If and , then the running time is . There are also many forms of polynomial time approximation algorithms applied to the subset problem. For an overall review of subset-sum problems and the different algorithms, we recommend the book by Keller et al. Kellerer et al. (2004).

Quantum algorithms in general provides computational speed-up over the classical counter parts. Quantum walk algorithm presented for element distinctness Ambainis (2007) is applied to the subset problems Childs and Eisenberg (2005). The computational complexity of this algorithm is shown to be bounded by , where is the number of items and is the subset size. In quantum computing, the cases where exponential speedups are possible are generally related to hidden subgroup problems: a few examples of these cases are the factoring Shor (1994), the dihedral hidden subgroup problem Regev (2004) and some lattice problems Kuperberg (2005). A review of the algorithms giving the exponential speedups in the solutions of algebraic problems are given in Ref.Childs and Van Dam (2010). There are also quantum optimization algorithms such as the ones in the adiabatic quantum computation Farhi et al. (2000, 2001); Aharonov et al. (2008) applied to different NP problems Lucas (2014) and the quantum approximate optimization algorithm Farhi et al. (2014) applied to the NP-hard problems. For a further review on general quantum algorithms, please refer to Ref. Bacon and VAn DAm (2010); Mosca (2012); Montanaro (2015), or to the introductory books Nielsen and Chuang (2002); Kaye et al. (2007).

It is known that having the ability of a post-selected quantum computing (an imaginary computing model), one can obtain the result of a Grover search problem in Farhi and Harrow (2016); Aaronson (2005)

. This ability would also lead a quantum computer to solve NP-complete problems in polynomial time. Although this model is imaginary, it still provides an insight to see one of the differences between quantum and classical computers on the solution of NP-complete problems: i.e., mainly a quantum computer can generate all the solution space and mark the correct answer in polynomial time, which is not possible on classical computers. However, this information, the marked item, can only be obtained by an observer with an exponential overhead (which makes the computational complexity exponential in the number of qubits.). This motivates to do research on the applications of the algorithms such as Grover’s search algorithm

Grover (1997) to the special cases of NP-complete problems so as to gain at least some speed-up over the classical algorithms.

The Grover search algorithm in quantum computing provides quadratic computational-speedup over the classical brute force search algorithm. It is well-known that the employment of this algorithm in general yields a quadratic speed-up also in the exact solutions of NP-complete problems (please see the explanation for Hamiltonian cycle given in page 263 of Ref.Nielsen and Chuang (2002)). The algorithm also plays important role in quantum Arthur-Merlin games Kitaev (1997); Marriott and Watrous (2005)

and applied along with the phase estimation algorithm to NP-complete problems such as 3-SAT and k-local Hamiltonian problems

Kitaev (1999); Aharonov and Naveh (2002). The similar idea is also used to prepare the ground state of the many-body quantum systems Poulin and Wocjan (2009); Nagaj et al. (2009). Here, we study the subset-sum problems by using a quantum heuristic approach similar to the verification circuits of quantum Arthur-Merlin gamesMarriott and Watrous (2005). The approach may provide exponential speed-up for the solution of the subset problems over the classical algorithms under the following assumptions:

Assumption 1.

Let be the number of possible subset-sums less than and be the number of possible subset-sums greater than or equal to . In this paper, we will assume that .

Under this assumption, the probability of having a subset-sum less than

is . However, we may still have number of possible subsets which gives a sum less than . Whence we can easily make the following remark:

Remark 1.

The subset-sum problem under this assumption is as difficult as without this assumption. Therefore, the maximization version of the problem is still NP-hard when .

In addition, the correctness of the solution produced by our heuristic is determined from the distribution (which can be guessed from the distribution of the input elements) of the feasible subset-sums. It yields the exact answer with a high-probability if the following condition is satisfied.

Assumption 2.

Let be the maximum subset-sum less than . Let -qubits in the output register of our algorithm represents the binary value of . If the bit value of any th qubit is 1 in the binary value of ; then after measuring the first number of qubits with the correct values , the probability of seeing on the th qubit is not exponentially small (i.e. the probability is .) in the normalized-collapsed state.

This assumption (condition) only affects the accuracy of the output. As we shall show in the following sections, it does not change the polynomial running time. In addition, to the best of our knowledge, this assumption does not simplify the original problem for the current classical algorithms: For instance, this condition is likely to hold when we have a random uniformly distributed set of input elements. As mentioned, generating possible subset-sums alone takes exponential time for any classical algorithm and the computational complexity of finding the solution is still bounded by

for any classical algorithm when .

In the following sections, after preliminaries, we list the algorithmic steps and explain each step in the subsections. Then, we discuss the complexity analysis and show how the approach takes time under the above assumptions. We also discuss the application to the knapsack problem. Finally, we present a numerical example and conclude the paper.

Ii Preliminaries

In this section, brief descriptions of the quantum algorithms used in this paper are given. For a broader understanding of these algorithms, the reader should refer to the introductory book by Chuang and Nielsen Nielsen and Chuang (2002).

ii.1 Notes on Notations

Throughout the paper, we will use

to represent a quantum state (a vector) and

to conjugate transpose of a vector. Bold faces such as indicates the vector is at least a two-dimensional vector. Using a value inside the ket-notation such as indicates the basis vector associated with the binary representation of . Other than which is a given value, the capital letters generally represent matrices (operators). The quantum state on a qubit represents 1 as a bit value and is 0. The indices start from 0.

ii.2 Quantum Phase Estimation Algorithm

Quantum phase estimation algorithm (PEA)Kitaev (1995)

is a well-known eigenvalue solver which estimates the phases of the eigenvalues of a unitary matrix,

: i.e. the eigenvalues of comes in the form of

with an associated eigenvector

. The algorithm estimates the value of for a given approximate eigenvector . The accuracy of the estimation is determined by the overlap of the approximate and actual eigenvectors and the number of qubits used to represent the phase value. PEA in general requires two registers to hold the value of the phase and the eigenvector. The algorithm starts with an initial approximation of the eigenvector on the second register and state on the first register:

. Then, the quantum Fourier transform is applied to the first register. It then the controlled-operators

s are applied to the second register in consecutive order: here, , each is controlled by the th qubit of the first register and is the size of this register which determines the decimal precision of the estimation. At this point in the first register the Fourier transform of the phase is obtained. Therefore, applying the inverse Fourier transform and measurement on the first register yields the estimation of .

In general, the computational complexity of PEA is governed by the number of gates used to implement each . When they can be implemented in polynomial time, then the complexity of the algorithm can be bounded by some polynomial time, .

ii.3 Amplitude Amplification Algorithm

The amplitude amplification (AA) is based on the Grover search algorithm Grover (1997) and used to amplify the part of a quantum state which is considered as “good”. The algorithm is mainly composed of two operators. The first operator, , marks (negates the signs of) the “good” states and the second operator, , amplifies the amplitudes of the marked states.

For ; . The implementation of depends on the function that describes the good part of the states. Through this paper, is simply some combination of controlled and gates ( and are Pauli spin matrices.).

If for some unitary matrix , then , where “*” represents the conjugate transpose. The amplification is done by applying the iterator consecutively to . The number of iteration depends on and is bounded by . For further details and variants of AA, please refer to Chapter 8 of Ref.Kaye et al. (2007).

Iii Algorithm

The approach uses a qubit and a rotation phase gate for each element of , to encode the possible subset sums as the eigen-phases of a diagonal unitary matrix . Then, it applies the phase estimation algorithm to obtain the possible sums and associate eigenvectors on two quantum registers. Marking the states with phases less than , it eliminates the states with phases greater through the amplitude amplification. Finally, it again employs the amplitude amplification in measurement processes to obtain the maximum phase and its associated eigenvector which indicates the solution of the problem. Here, first the algorithmic steps in general are listed, and then the explanations and more details for each steps are given in the following subsections. The steps are generalized as follows:

  1. Encode the integer values as the phases of the rotation gates aligned on different qubits.

  2. Apply the phase estimation algorithm to the equal superposition state so as to produce the phases and the associated eigenvectors on quantum registers.

  3. Apply the amplitude amplification to eliminate the states where . Now, the superposition of the sums and the eigenvectors are obtained with equal probabilities.

  4. Find the maximum in the first register. Then, measure the second register to attain the solution.

The quantum circuit representing the above steps is drawn in Fig.1.

iii.1 Encoding the Values into the Phases

First, the values are scaled so that . For each value with , a rotation gate in the following form is put on the st qubit:

(1)

The -qubit circuit formed with these rotation gates can be then represented by the following unitary matrix:

(2)

Here, is a diagonal matrix with the diagonal elements (eigenvalues):

(3)

As seen in the above, the phases of the eigenvalues associated with the eigenvectors forming the standard-basis-set encode all the possible sum and the subset information: i.e. the vector in the standard basis indicates the phase and the elements of the th subset.

iii.2 Generating All Possible Sums and Subsets on Registers

Consider the phase estimation algorithm applied to with the following initial state:

(4)

Here, can be simply generated by , where

represents an identity matrix and

is the Hadamard matrix. Since the eigenvectors of are of the standard basis, the final output of the phase estimation holds the equal superposition of the eigenvector and phases:

(5)

where represents the phase estimation algorithm applied to and forms the first part of the circuit in Fig.1. Obviously if we are able to efficiently find the index of the maximum less than in the above, then we solve the maximum subset-sum problem efficiently.

iii.3 Eliminating the Subsets with

Before searching for the solution, we divide the quantum state in Eq.(5) into two parts:

(6)

where and with . This equation includes all the possible eigenpairs. To eliminate the ones included in , we apply the amplitude amplification algorithm defined by the iterator as shown in Fig.1. Here, operates on the first register and flips the sign of the states with :

(7)

and can be implemented as follows:

(8)

where .

After each iteration, the amplitudes of the “good” states are amplified. The number of iterations in the algorithm (the number of applications of ) is determined by the initial probability and is bounded by . In the worst case where , the complexity becomes . However, in the other cases, the number of iterations is bounded by . In addition, using the quantum counting one can estimate the value of and in polynomial time (see quantum counting in Chapter 8 of Ref.Kaye et al. (2007)).

As explained in the Introduction, in this paper we make the assumption given in Assumption 1: i.e., mainly . As a result of this assumption, this part of the algorithm takes time. And at the end of the amplitude amplification, the final quantum state becomes:

(9)

iii.4 Finding the Maximum Sum with Its Subset

Grover search algorithm Grover (1997) is able to find a maximum or minimum element of a list of items in times Durr and Hoyer (1996). It can be directly applied to Eq.(9) to find the maximum of s and the value of . However, this makes the running time of the whole algorithm exponential because of Assumption 1.

The elements of the set is partially sorted and mostly for a considerably large . Therefore, in some cases, quantum binary search algorithm (e.g. Ambainis (1999); Høyer et al. (2002)) can be used to produce an approximate solution. This will require time complexity.

Below, similarly to the binary search algorithm and the verification circuit given Marriott and Watrous (2005), a polynomial time method for finding the maximum is presented by applying a sequence of conditional amplitude amplifications: Let us assume the maximum in Eq.(9) is . If we try to maximize the measurement outcome of the first register, then we attain a value close to . This maximization can be done by starting the measurement from the most significant qubits while trying to measure as many qubits in state as possible. Therefore, we will measure a qubit: if the outcome is not , then we apply the amplitude amplification to amplify the states where this qubit is in state and then do the measurement again. If the qubit does not yield after a few iterations, then we will assume as the qubit value and move on to the next qubit. And we repeat this process for the all qubits in the first register. This is explained in more details below and indicated in Fig.1 (Note that the measurements after each amplitude amplification is omitted in the figure.):

  • We measure the first qubit (representing the most significant bit, ):

    • If it is , then we set = and move on to the next qubit in the collapsed state.

    • Otherwise, we apply the amplitude amplification by flipping the signs of the states in which the first qubit is in state. While the flipping can be done by simply using the Pauli -gate, the amplification operator, , can be implemented in a way similar to Eq.(8):

      (10)

      where represents all the quantum operations up to this point. Here, we only apply the iterator a few times until the measurement yields . If it does not, then is set to .

  • In the second qubit, we repeat the same process. However, this time ; where, involves all the operations done up to this point, and the gate is the controlled- gate acting on the second qubit and controlled by the first qubit: if the first qubit was , then the control bit is (i.e. the gate acts when the first qubit is .). Otherwise, it is set to .

  • Similarly, using gates controlled by the previous qubits, the measurements along with the amplitude amplifications are repeated for the remaining qubits. Here, the control-bits are either 0 or 1 determined from the measurement results of the previous qubits.

The above maximization method is able to amplify the amplitude of if at any point the probability to measure on the qubit is not exponentially small. Otherwise, the number of the amplitude amplification required to see on that qubit becomes exponentially large. Since the amplitude amplification is only applied a few times (when is not encountered, the qubit is assumed to be ), this will cause an error in the result. Let us assume that the condition given in Assumption 2 holds: i.e., if the bit value of any th qubit is 1 in the binary value of ; then after the individual measurements of the first number of qubits with the values , the probability of seeing on the th qubit is not exponentially small in the normalized-collapsed state. This assumption affects the accuracy of the result rather than the running time since the amplitude amplification on a qubit is applied only a few times and when is not encountered, the related bit value of is assumed 0.

To further simplify the circuit in Fig.1 and the numerical simulations, we will also make following remark:

Figure 1: The general circuit for the algorithm: with . And and so on.
Remark 2.

can be used in places of to simplify the implementation of the amplitude amplifications.

The circuit in accordance with the above remark is presented in Fig.2 (The measurements on the qubits are also explicitly indicated in this figure however not in Fig.1). Sect. VI gives a numerical example based on this circuit. Now, we will explain how this circuit may yield the solution by going through the measurements of the first two qubits on the circuit: Let us first divide the state given in Eq.(9) (the state after in Fig.2) into four parts with the same length:

(11)

The probabilities of measuring and on the first qubit are and , respectively. If is not exponentially less than , then with the help of the amplitude amplification (), the first qubit, can be measured in . Therefore, becomes 1. Let us assume we obtain after the measurement. If we use a qubit in place of the first qubit and initialize it in state, we obtain the following normalized-sate:

(12)

For the second qubit, the part represented by is marked by the controlled gate, and then is applied:

(13)

where . Due to , :

  • If , then all of the amplitudes in the above quantum states are unmarked. Therefore, in the subsequent iteration of AA only will be marked, and the amplitudes corresponding to will be amplified.

  • If , that means the probability difference between and is small; thus, we are very likely to measure after the first amplitude amplification. After the measurement, the state collapses to

    (14)
Figure 2: The circuit for the algorithm according to Remark 2 with 4 qubits on the first register: and .

Iv Complexity Analysis

We will follow the circuit in Fig.1 to analyze the complexity of the whole approach under Assumption 1 and 2. The algorithm starts with two quantum registers of respectively and qubits, and then later in the maximum finding part of the algorithm it uses another register with qubits which is implicitly indicated in Fig.2 but not in Fig.1. Therefore, the total number of qubits employed in the whole running of the algorithm is .

Since involves only phase gates described in Eq.(1), using , in the phase estimation requires only number of controlled phase gates (Note that the power of the unitary can be taken by simply changing the angles of the rotation gates.). Therefore, including the complexity of the quantum Fourier transform Nielsen and Chuang (2002), , the phase estimation part, requires number of quantum gates.

In the amplitude amplification part, the operator can be designed in time by using a logical circuit: i.e., the circuit is composed of and gates and marks all of the states less than . Moreover, the implementation of defined in Eq.(8) involves the Hadamard gates, and all of which can be implemented in polynomial time.

The remaining part of the circuit is for finding maximum and involves s and controlled- gates. The implementation of any is similar to the operator : they involve the repetitions of the circuit up to their location, and hence requires more computations. However, because of Assumption 2, this part of the circuit and the whole processes are still bounded by some polynomial time, .

V Application to 1/0-Knapsack Problem

The maximum subset-sum problem is related to many other problems. One of these is the 1/0-knapsack problem Kellerer et al. (2004) described as: For a given items with weights and values , determine which items should be included in a subset to maximize the total subset-value while keeping the total-weight less than . This problem can be solved in a similar fashion to the subset-problem by adding one additional register to the algorithm:

  • – The first register holds the sum of the weights.

  • – The second register holds the values.

  • – The third register indicates the items included in the subset: describes the th vector in the standard basis.

The algorithm starts with constructing the superposition of the possible sums of weights and values as a quantum state by using the phase gates where the least-significant-bits encode the item-values while the most-significant bits are used for the weights. After the phase estimation, the following quantum state is generated:

(15)

Then, applying the amplitude amplification, the states where are eliminated and the probability of the states where are put into the equal superposition:

(16)

Now, the maximum finding is done on the second register: After finding with the maximum decimal value, the solution to the knapsack problem is obtained from the corresponding which indicates the involved items.

Vi Numerical Example

In this section, we present a random numerical example based on the circuit in Fig.2. Let us assume that given the set of values

(17)

which are normalized so that the maximum possible sum is at most 0.5, we are asked to find the subset which gives the maximum possible sum less than . If we use 9 bits of precision: i.e. (the size of the first register in PEA), then ).

We start with the construction of which requires a qubit and a single rotation gate for each element of : that means (the size of the second-register in PEA) and . The eigen-phases of shown in Fig.3 represents the solution space, the possible subset-sums of . Fig.4 depicts the distribution of these phases.

Figure 3: Phases.
Figure 4: Distribution of the eigen-phases.

After PEA is applied with an initial superposition state on the second register; using AA, the amplitudes of the states in which the phase value on the first register is less than are marked and amplified. After one iteration of AA, the probability of the eigenvector-phase pairs are presented in Fig(a)a. At this point, we have .

In the maximum-finding part, we start doing the measurement from the most significant qubits:

  • Qubit-1 and qubit-2 yields s with probability s. Therefore, = . After the normalization, we have the solution space where all s are less than . This is shown in Fig.(b)b.

  • The measurement on qubit-3 yields either or with probabilities, respectively, and . Therefore, it is very likely is measured after a few attempts. In that case, we have = on the first three qubits and the collapsed-state on the remaining qubits. The normalized probabilities at this point are drawn on Fig.(c)c.

  • The probabilities of and for qubit-4 is and in the normalized state. After a few measurements, if we see , we set = and continue on the fifth qubit. Otherwise, we apply the amplitude amplification. This changes the probabilities for qubit-4 to and , respectively. However, it also brings back some of the eliminated states with some small probabilities. This is shown in Fig.(d)d. After the measurement of qubit-4 in , the state collapses into four remaining eigenpairs with equal probabilities shown in Fig.(e)e.

  • In all of these four states, qubit-5 and qubit-6 are in state. Therefore, the measurements on these qubits yield states with probability 1.

  • The probability of seeing qubit-7 in state is 0.25. An iteration of AA amplifies this to 0.3488 as shown in Fig.(f)f. At this point, after a few measurements, we are likely to encounter on qubit-7. This collapses the state into the solution.

  • And finally, qubit-8 and qubit-9 are measured in with probability 1.

The above maximization yields 0.1953125 as the maximum phase with as the corresponding eigenvector, which is the exact solution.

(a) The probabilities of the eigenpairs after the amplitude amplification.
(b) The probabilities after the measurements of qubit-1 and qubit-2 in states with probability 1.
(c) The probabilites after the measurement of qubit-3 in state with probability 0.5610.
(d) The probabilities after AA is apllied for the fourth qubit. The measurement of qubit-4 yields state with probability 0.8009:The probability was 0.1739 after one iteration of AA, it is amplified to 0.8009.
(e) The probabilities after the measurements of qubit-4 in and qubit-5 and qubit-6 in states with the probabilities 0.8009, 1, and 1, respectively.
(f) The probability of the states after AA is applied for qubit-7. The measurement on qubit-7 yields with probability 0.3488: The probability was 0.25, it is amplified to 0.3488 through one iteration of AA. At this point, the state collapses to the solution.
Figure 5: The probabilities of the states after the amplitude amplification and the measurements of qubits according to the circuit given in Fig.2.

Vii Conclusion

In this paper we have studied the subset-sum and similar problems: e.g. the knapsack problem. In particular, we have generated the possible sums by using the phase estimation and the amplitude amplification algorithms. Then, we have used a maximum-finding procedure to obtain the solution. The approach requires polynomial time if the number of possible sums less than or equal to the given value are not exponentially smaller than the number of possible sums greater than the value. In addition, it yields the exact answer if the probability of seeing the correct bit value on the th qubit is not exponentially small in the normalized-collapsed state after the first number of most significant bit values are correctly measured. The approach is general and can be further improved for the similar NP-complete problems.

References

  • Marriott and Watrous [2005] Chris Marriott and John Watrous. Quantum arthur–merlin games. Computational Complexity, 14(2):122–152, 2005.
  • Kellerer et al. [2004] Hans Kellerer, Ulrich Pferschy, and David Pisinger. Introduction to np-completeness of knapsack problems. In Knapsack problems, pages 483–493. Springer, 2004.
  • Ambainis [2007] Andris Ambainis. Quantum walk algorithm for element distinctness. SIAM Journal on Computing, 37(1):210–239, 2007.
  • Childs and Eisenberg [2005] Andrew M. Childs and Jason M. Eisenberg. Quantum algorithms for subset finding. Quantum Info. Comput., 5(7):593–604, November 2005. ISSN 1533-7146. URL http://dl.acm.org/citation.cfm?id=2011656.2011663.
  • Shor [1994] Peter W Shor. Algorithms for quantum computation: Discrete logarithms and factoring. In Foundations of Computer Science, 1994 Proceedings., 35th Annual Symposium on, pages 124–134. Ieee, 1994.
  • Regev [2004] Oded Regev. Quantum computation and lattice problems. SIAM Journal on Computing, 33(3):738–760, 2004.
  • Kuperberg [2005] Greg Kuperberg. A subexponential-time quantum algorithm for the dihedral hidden subgroup problem. SIAM Journal on Computing, 35(1):170–188, 2005.
  • Childs and Van Dam [2010] Andrew M Childs and Wim Van Dam. Quantum algorithms for algebraic problems. Reviews of Modern Physics, 82(1):1, 2010.
  • Farhi et al. [2000] Edward Farhi, Jeffrey Goldstone, Sam Gutmann, and Michael Sipser. Quantum computation by adiabatic evolution. arXiv preprint quant-ph/0001106, 2000.
  • Farhi et al. [2001] Edward Farhi, Jeffrey Goldstone, Sam Gutmann, Joshua Lapan, Andrew Lundgren, and Daniel Preda. A quantum adiabatic evolution algorithm applied to random instances of an np-complete problem. Science, 292(5516):472–475, 2001.
  • Aharonov et al. [2008] Dorit Aharonov, Wim Van Dam, Julia Kempe, Zeph Landau, Seth Lloyd, and Oded Regev. Adiabatic quantum computation is equivalent to standard quantum computation. SIAM review, 50(4):755–787, 2008.
  • Lucas [2014] Andrew Lucas. Ising formulations of many np problems. Frontiers in Physics, 2:5, 2014. ISSN 2296-424X. doi: 10.3389/fphy.2014.00005. URL http://journal.frontiersin.org/article/10.3389/fphy.2014.00005.
  • Farhi et al. [2014] Edward Farhi, Jeffrey Goldstone, and Sam Gutmann. A quantum approximate optimization algorithm. arXiv preprint arXiv:1411.4028, 2014.
  • Bacon and VAn DAm [2010] Dave Bacon and Wim VAn DAm. Recent progress in quantum algorithms. Communications of the ACM, 53(2):84–93, 2010.
  • Mosca [2012] Michele Mosca. Quantum algorithms. In Computational Complexity, pages 2303–2333. Springer, 2012.
  • Montanaro [2015] Ashley Montanaro. Quantum algorithms: an overview. npj Quantum Information, 2(15023), 2015.
  • Nielsen and Chuang [2002] Michael A Nielsen and Isaac Chuang. Quantum computation and quantum information, 2002.
  • Kaye et al. [2007] Phillip Kaye, Raymond Laflamme, and Michele Mosca. An introduction to quantum computing. Oxford University Press, 2007.
  • Farhi and Harrow [2016] Edward Farhi and Aram W Harrow. Quantum supremacy through the quantum approximate optimization algorithm. arXiv preprint arXiv:1602.07674, 2016.
  • Aaronson [2005] Scott Aaronson. Quantum computing, postselection, and probabilistic polynomial-time. In Proceedings of the Royal Society of London A: Mathematical, Physical and Engineering Sciences, volume 461, pages 3473–3482. The Royal Society, 2005.
  • Grover [1997] Lov K Grover. Quantum mechanics helps in searching for a needle in a haystack. Physical review letters, 79(2):325, 1997.
  • Kitaev [1997] A Yu Kitaev. Quantum computations: algorithms and error correction. Russian Mathematical Surveys, 52(6):1191–1249, 1997.
  • Kitaev [1999] Alexei Kitaev. Quantum np. Talk at AQIP, 99, 1999.
  • Aharonov and Naveh [2002] Dorit Aharonov and Tomer Naveh. Quantum np-a survey. arXiv preprint quant-ph/0210077, 2002.
  • Poulin and Wocjan [2009] David Poulin and Pawel Wocjan. Preparing ground states of quantum many-body systems on a quantum computer. Physical review letters, 102(13):130503, 2009.
  • Nagaj et al. [2009] Daniel Nagaj, Pawel Wocjan, and Yong Zhang. Fast amplification of qma. Quantum Info. Comput., 9(11):1053–1068, November 2009. ISSN 1533-7146.
  • Kitaev [1995] A Yu Kitaev. Quantum measurements and the abelian stabilizer problem. arXiv preprint quant-ph/9511026, 1995.
  • Durr and Hoyer [1996] Christoph Durr and Peter Hoyer. A quantum algorithm for finding the minimum. arXiv preprint quant-ph/9607014, 1996.
  • Ambainis [1999] Andris Ambainis. A better lower bound for quantum algorithms searching an ordered list. In Foundations of Computer Science, 1999. 40th Annual Symposium on, pages 352–357. IEEE, 1999.
  • Høyer et al. [2002] Peter Høyer, Jan Neerbek, and Yaoyun Shi. Quantum complexities of ordered searching, sorting, and element distinctness. Algorithmica, 34(4):429–448, 2002.