Brute-force is apparently applicable to any problem of NP, since if you have some candidate for an answer, you can easily check / verify this candidate (but finding a candidate is still hard).

For example: given a phone number to find its owner in the phone book, you can easily check it, but you need n/2 time to find it on average. Another example is the traveling salesperson problem, where you don’t have the path but only desired length, finding the path is complicated, in the worst case you need n! time where n is the number of vertices.

For any problem that is solvable by brute-force search, if you can speed up the brute-force search with a quantum computer, you can make the process more effective. Lov Grover dealt with quantum algorithm which is able to solve any problem of NP, independent of its structure.

## Grover’s Algorithm

Consider the phone book problem, where owners’ names are arranged in alphabetized order, it is easy to find the phone number given a name. This could be formalized as a function `f: {0,1}`

, there exists ω (a name) in the domain, such that ^{n} → {0,1}^{n}`f(ω) = a`

, where a is the phone number. Having `f(ω)`

defined, we could further define another function `f`

, which maps n-bit integer to 1 bit:_{ω}(x) = δ_{x=ω}

`f`_{ω}(x ≠ ω) = 0
f_{ω}(x = ω) = 1

In quantum computing, the function `f`

is defined as an operator _{ω}`U`

as usual:_{f}

`U`_{f}|x⟩|y⟩ = |x⟩|y ⊕ f_{ω}(x)⟩

If we pass through the `|y⟩`

register the Hadamard `|-⟩`

, we have this express as usual:

`U`_{f} 1/√2 |x⟩(|0⟩-|1⟩)
= 1/√2 |x⟩(|0 ⊕ f_{ω}(x)⟩ - |1 ⊕ f_{ω}(x)⟩)
= 1/√2 (-1)^{fω(x)} |x⟩(|0⟩ - |1⟩)

We only consider the projection `U`

, which works like below:_{ω}|x⟩ = (-1)^{fω(x)} |x⟩

`∀ |x⟩ ≠ |ω⟩ U`_{ω}|x⟩ = |x⟩
∀ |x⟩ = |ω⟩ U_{ω}|ω⟩ = -|ω⟩

Actually, the `U`

operator can be rewritten like this:_{ω}|x⟩

`U`_{ω}|x⟩ = I - 2|ω⟩⟨ω|

The input data of the Grover’s algorithm is `|s⟩ = H|0⟩`

, here we can define another useful operator:^{n} = 1/2^{n/2} Σ^{2^n-1}_{x=0} |x⟩

`U`_{s} = 2|s⟩⟨s| - I

Each iteration of the Grover’s algorithm is: `R`

. After applying k iterations on initial state _{grov} = U_{s} U_{ω}`|s⟩`

, we have something like this: `(U`

._{s} U_{ω})^{k} |s⟩

`|ω⟩`

is a vector in the space with dimensionality N. `|s⟩ = 1/√N ∑`

. The sine of the angle θ between ^{N−1}_{x=0} |x⟩`|s⟩`

and the hyperplane which is orthogonal to `|ω⟩`

, is `sin(θ) = 1/√N`

.

Each iteration of Grover’s algorithm makes us closer to the state `|ω⟩`

with each step `2θ`

. Suppose we have made T iterations, `T ≈ (π/4)√N`

. The time need to find a solution is O(√N).

Why we choose the vector `|s⟩`

as an initial state? `|s⟩`

has equal angles to all the basis vectors of the space. We don’t know anything about `|ω⟩`

, but we must know `θ`

.

When there are multiple `ω`

, such that _{i}`f`

, 1 ≤ i ≤ k . The algorithm does not change, but we have k vectors, and angle _{ω}(ω_{i}) = 1`θ`

becomes greater. The sine of the angle `θ`

between `|s⟩`

and the hyperplane which is orthogonal to all vectors |ω_{i}⟩, is now `sin(θ) = √k/√N`

. And `T ≈ (π/4)*(√N/√k)`

.

Note that to use Grover’s algorithm, we must know the number of special points k to calculate the number of iterations T. Grover’s algorithm does not tolerate extra work. If you do more iterations than it’s needed, we may pass this point of interest.

The reason we choose operator `U`

is because it reflect in the desired direction. _{s}`|s⟩`

is the only thing we know in this space, i.e. the equally weighted sum of all basis vectors.

### Optimality

Lov Grover proved that there is no better algorithm than Grover’s algorithm. Suppose:

- The target is
`|ω⟩`

. - There exist, in general, some operator better:
`U(ω,t) = U`

. Here U_{t}U_{ω}U_{t-1}U_{ω}...U_{1}U_{ω}_{t}is the generalization of U_{s}in Grover’s algorithm. `|ψ`

is the initial state._{0}⟩`|ψ`

_{t}⟩ = U(ω,t)|ψ_{0}⟩- T is defined as
`U(ω,t)|ψ`

_{0}⟩ = |ψ_{T}⟩ = |ψ_{ω}⟩ ≈ |ω⟩ - We are going to find some vector
`|ϕ⟩`

for which this double inequality is true:

`4T`^{2} ≥ ∑^{N-1}_{ω=0} || |ψ_{ω}⟩ - |φ⟩ ||^{2} ≥ 2N - 2√N
⟹ 4T^{2} ≥ 2N - 2√N
⟹ T ≈ √N/√2

Compare the T with that of Grover’s algorithm (`T`

). The most effective algorithm is not very much better than that of Grover’s._{grov} = (π/4)√N

## Quantum Computers aren’t Always Better

Quantum computers are not always better than classical ones. There are problems on which the quantum computers are almost as ineffective as classical ones.

Let’s consider all the functions of type `f(x): {0,1}`

, and for any such functions, we could introduce the value ^{n} → {0,1}`x = x`

, which is a very long bit string._{N-1}x_{N-2}...x_{0}, N = 2^{n}

Function Parity() maps functions to 1 bit. First each bit `x`

is used to calculate _{i}`x`

, then parity is calculated:^{~}_{i}

`x`^{~}_{i} = 1 - 2x_{i}
Parity(x^{~}) = ∏^{N-1}_{i=0} x^{~}_{i}

If there are even numbers of 1 in x, the parity is 1; if there is odd number of 1 in x, the parity is -1.

To calculate the parity of a function of type `f(x): {0,1}`

, in classical computing, we have to try all the function values and multiply them. However quantum computer can not outperform classical ones on this task.^{n} → {0,1}

## My Certificate

For more on Grover’s Algorithm, please refer to the wonderful course here https://www.coursera.org/learn/quantum-computing-algorithms

## Related Quick Recap

*I am Kesler Zhu, thank you for visiting my website. Check out more course reviews at https://KZHU.ai*

Don't forget to sign up newsletter, don't miss any chance to learn.

Or share what you've learned with friends!

Tweet