**Amplitude amplification** is a technique in quantum computing which generalizes the idea behind Grover's search algorithm, and gives rise to a family of quantum algorithms.
It was discovered by Gilles Brassard and Peter Høyer in 1997,^{[1]} and independently rediscovered by Lov Grover in 1998.^{[2]}

In a quantum computer, amplitude amplification can be used to obtain a quadratic speedup over several classical algorithms.

The derivation presented here roughly follows the one given by Brassard et al. in 2000.^{[3]}
Assume we have an -dimensional Hilbert space representing the state space of a quantum system, spanned by the orthonormal computational basis states .
Furthermore assume we have a Hermitian projection operator .
Alternatively, may be given in terms of a Boolean oracle function
and an orthonormal operational basis
,
in which case

- .

can be used to partition into a direct sum of two mutually orthogonal subspaces, the *good* subspace and the *bad* subspace :

In other words, we are defining a "

Given a normalized state vector with nonzero overlap with both subspaces, we can uniquely decompose it as

- ,

where ,
and
and are the normalized projections of into the subspaces and , respectively. This decomposition defines a two-dimensional subspace
, spanned by the vectors
and .
The probability of finding the system in a *good* state when measured is .

Define a unitary operator , where

flips the phase of the states in the *good* subspace, whereas
flips the phase of the initial state .

The action of this operator on is given by

- and
- .

Thus in the subspace corresponds to a rotation by the angle :

- .

Applying times on the state gives

- ,

rotating the state between the *good* and *bad* subspaces.
After iterations the probability of finding the
system in a *good* state is .

The probability is maximized if we choose

- .

Up until this point each iteration increases the amplitude of the *good* states, hence the name of the technique.

Assume we have an unsorted database with N elements, and an oracle function which can recognize the *good* entries we are searching for, and for simplicity.

If there are *good* entries in the database in total, then we can find them by initializing a quantum register with qubits where into a uniform superposition of all the database elements such that

and running the above algorithm. In this case the overlap of the initial state with the *good* subspace is equal to the square root of the frequency of the *good* entries in the database, . If , we can approximate the number of required iterations as

Measuring the state will now give one of the *good* entries with high probability. Since each application of requires a single oracle query (assuming that the oracle is implemented as a quantum gate), we can find a *good* entry with just oracle queries, thus obtaining a quadratic speedup over the best possible classical algorithm. (The classical method for searching the database would be to perform the query for every until a solution is found, thus costing queries.) Moreover, we can find all solutions using queries.

If we set the size of the set to one, the above scenario essentially reduces to the original Grover search.

Suppose that the number of *good* entries is unknown. We aim to estimate such that for small . We can solve for by applying the quantum phase estimation algorithm on unitary operator .

Since and are the only two eigenvalues of , we can let their corresponding eigenvectors be and . We can find the eigenvalue of , which in this case is equivalent to estimating the phase . This can be done by applying Fourier transforms and controlled unitary operations, as described in the quantum phase estimation algorithm. With the estimate , we can estimate , which in turn estimates .

Suppose we want to estimate with arbitrary starting state , instead of the eigenvectors and . We can do this by decomposing into a linear combination of and , and then applying the phase estimation algorithm.