Quantum Amplitude Amplification#

amplitude_amplification(args, state_function, oracle_function, kwargs_oracle={}, iter=1, reflection_indices=None)[source]#

This method performs quantum amplitude amplification.

The problem of quantum amplitude amplification is described as follows:

• Given a unitary operator $\mathcal{A}$, let $|\mathrm{\Psi }⟩=\mathcal{A}|0⟩$.

• Write $|\mathrm{\Psi }⟩=|{\mathrm{\Psi }}_1⟩+|{\mathrm{\Psi }}_0⟩$ as a superposition of the orthogonal good and bad components of $|\mathrm{\Psi }⟩$.

• Enhance the probability $a=⟨{\mathrm{\Psi }}_1|{\mathrm{\Psi }}_1⟩$ that a measurement of $|\mathrm{\Psi }⟩$ yields a good state.

Let ${\theta }_a\in [0,\pi /2]$ such that ${\sin }^2({\theta }_a)=a$. Then the amplitude amplification operator $\mathcal{Q}$ acts as

$${\mathcal{Q}}^j|\mathrm{\Psi }⟩=\frac{1}{\sqrt{a}}\sin ((2j+1){\theta }_a)|{\mathrm{\Psi }}_1⟩+\frac{1}{\sqrt{1-a}}\cos ((2j+1){\theta }_a)|{\mathrm{\Psi }}_0⟩.$$

Therefore, after $m$ iterations the probability of measuring a good state is ${\sin }^2((2m+1){\theta }_a)$.

Parameters:

argsQuantumVariable or list[QuantumVariable]

The (list of) QuantumVariables which represent the state, the amplitude amplification is performed on.

state_functionfunction

A Python function preparing the state $|\mathrm{\Psi }⟩$. This function will receive the variables in the list args as arguments in the course of this algorithm.

oracle_functionfunction

A Python function tagging the good state $|{\mathrm{\Psi }}_1⟩$. This function will receive the variables in the list args as arguments in the course of this algorithm.

kwargs_oracledict, optional

A dictionary containing keyword arguments for the oracle. The default is {}.

iterint, optional

The amount of amplitude amplification iterations to perform. The default is 1.

refection_indiceslist[int], optional

A list indicating with respect to which variables the reflection within the diffuser is performed, i.e. oblivious amplitude amplification is performed. By default, the reflection is performed with respect to all variables in args, i.e. standard amplitude amplification is performed.

Examples

We define a function that prepares the state $|\mathrm{\Psi }⟩=\cos (\frac{\pi }{16})|0⟩+\sin (\frac{\pi }{16})|1⟩$ and an oracle that tags the good state $|1⟩$. In this case, we have $a={\sin }^2(\frac{\pi }{16})\approx 0.19509$.

from qrisp import z, ry, QuantumBool, amplitude_amplification
import numpy as np

def state_function(qb):
    ry(np.pi/8,qb)

def oracle_function(qb):   
    z(qb)

qb = QuantumBool()

state_function(qb)

>>> qb.qs.statevector(decimals=5)
0.98079∣False⟩+0.19509∣True⟩

We can enhance the probability of measuring the good state with amplitude amplification:

>>> amplitude_amplification([qb], state_function, oracle_function)
>>> qb.qs.statevector(decimals=5)
0.83147*|False> + 0.55557*|True> 

>>> amplitude_amplification([qb], state_function, oracle_function)
>>> qb.qs.statevector(decimals=5)
0.55557*|False> + 0.83147*|True> 

>>> amplitude_amplification([qb], state_function, oracle_function)
>>> qb.qs.statevector(decimals=5)
0.19509*|False> + 0.98079*|True>