# Quantum Amplitude Estimation#

QAE(args, state_function, oracle_function, kwargs_oracle={}, precision=None, target=None)[source]#

This method implements the canonical quantum amplitude estimation (QAE) algorithm by Brassard et al..

The problem of quantum amplitude estimation is described as follows:

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

• Write $$\ket{\Psi}=\ket{\Psi_1}+\ket{\Psi_0}$$ as a superposition of the orthogonal good and bad components of $$\ket{\Psi}$$.

• Find an estimate for $$a=\langle\Psi_1|\Psi_1\rangle$$, the probability that a measurement of $$\ket{\Psi}$$ yields a good state.

Parameters
argsQuantumVariable or list[QuantumVariable]

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

state_functionfunction

A Python function preparing the state $$\ket{\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 $$\ket{\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 {}.

precisionint, optional

The precision of the estimation. The default is None.

targetQuantumFloat, optional

A target QuantumFloat to perform the estimation into. The default is None. If given neither a precision nor a target, an Exception will be raised.

Returns
resQuantumFloat

A QuantumFloat encoding the angle $$\theta$$ as a fraction of $$\pi$$, such that $$\tilde{a}=\sin^2(\theta)$$ is an estimate for $$a$$.

More precisely, we have $$\theta=\pi\frac{y}{M}$$ for $$y\in\{0,\dotsc,M-1\}$$ and $$M=2^{\text{precision}}$$. After measurement, the estimate $$\tilde{a}=\sin^2(\theta)$$ satisfies

$|a-\tilde{a}|\leq\frac{2\pi}{M}+\frac{\pi^2}{M^2}$

with probability of at least $$8/\pi^2$$.

Examples

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

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

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

def oracle_function(qb):
z(qb)

qb = QuantumBool()

res = QAE([qb], state_function, oracle_function, precision=3)

>>> res.get_measurement()
{0.125: 0.5, 0.875: 0.5}


That is, after measurement we find $$\theta=\frac{\pi}{8}$$ or $$\theta=\frac{7\pi}{8}$$ with probability $$\frac12$$, respectively. Therefore, we obtain the estimate $$\tilde{a}=\sin^2(\frac{\pi}{8})$$ or $$\tilde{a}=\sin^2(\frac{7\pi}{8})$$. In this case, both results coincide with the exact value $$a$$.

Numerical integration

Here, we demonstarate how to use QAE for numerical integration.

Consider a continuous function $$f\colon[0,1]\rightarrow[0,1]$$. We wish to evaluate

$A=\int_0^1f(x)\mathrm dx.$

For this, we set up the corresponding state_function acting on the input_list:

from qrisp import QuantumFloat, QuantumBool, control, z, h, ry, QAE
import numpy as np

n = 6
inp = QuantumFloat(n,-n)
tar = QuantumBool()
input_list = [inp, tar]


Here, $$N=2^n$$ is the number of sampling points the function $$f$$ is evaluated on. The state_function acts as

$\ket{0}\ket{0}\rightarrow\frac{1}{\sqrt{N}}\sum\limits_{x=0}^{N-1}\ket{x}\left(\sqrt{1-f(x/N)}\ket{0}+\sqrt{f(x/N)}\ket{1}\right).$

Then the probability of measuring $$1$$ in the target state tar is

$p(1)=\frac{1}{N}\sum\limits_{x=0}^{N-1}f(x/N),$

which acts as an approximation for the value of the integral $$A$$.

The oracle_function, therefore, tags the $$\ket{1}$$ state of the target state:

def oracle_function(inp, tar):
z(tar)


For example, if $$f(x)=\sin^2(x)$$ the state_function can be implemented as follows:

def state_function(inp, tar):
h(inp)

N = 2**inp.size
for k in range(inp.size):
with control(inp[k]):
ry(2**(k+1)/N,tar)


Finally, we apply QAE and obtain an estimate $$a$$ for the value of the integral $$A=0.27268$$.

prec = 6
res = QAE(input_list, state_function, oracle_function, precision=prec)
meas_res = res.get_measurement()

theta = np.pi*max(meas_res, key=meas_res.get)
a = np.sin(theta)**2

>>> a
0.26430