Requires coherent, controlled access to the state-preparation unitary and its inverse, and a bound on the observable's eigenvalues or on its tail distribution. A state that has been prepared and measured cannot be reused, so this is a fault-tolerant-regime method while direct sampling is the near-term one. The sign matters: Brassard, Høyer, Mosca and Tapp define $Q$ with a global minus, which fixes the eigenphase convention the amplitude is read off from.

A preparation routine $A$ with $A\lvert 0\rangle = \lvert \psi\rangle$, or repeated copies of $\rho$; a description of $O$; a target additive error $\varepsilon$ and a confidence $1-\delta$. Coherent, controlled access to $A$ and $A^\dagger$ is required by some methods here and by none of the sampling-based ones.

1. State you can prepare → Number with an error barphase-estimate the Grover iterate

   The whole method rests on the Grover iterate $Q = -AS_{0}A^{-1}S_{\chi}$ leaving a two-dimensional space invariant. On it $Q$ has eigenvectors $|\Psi_{\pm}\rangle = \frac{1}{\sqrt{2}}\left(\frac{1}{\sqrt{a}}|\Psi_{1}\rangle \pm \frac{i}{\sqrt{1-a}}|\Psi_{0}\rangle\right)$ and eigenvalues $\lambda_{\pm} = e^{\pm i2\theta_{a}}$, where $\sin^{2}(\theta_{a}) = a = \langle\Psi_{1}|\Psi_{1}\rangle$. assumption: that decomposition needs $0 < a < 1$ — both the flagged and unflagged branches of $A|0\rangle$ must be present, or the subspace collapses to one dimension. Since $A|0\rangle = \frac{-i}{\sqrt{2}}(e^{i\theta_{a}}|\Psi_{+}\rangle - e^{-i\theta_{a}}|\Psi_{-}\rangle)$, the eigenphase carries $a$: the algorithm Fourier-transforms an $M$-dimensional ancilla, applies $\Lambda_{M}(Q)$ so branch $j$ picks up $e^{\pm i2j\theta_{a}}$, inverse-transforms and measures $y$. approximation: a register of size $M$ resolves $\theta_{a}$ only to a multiple of $\pi/M$, so the reported $\tilde{a} = \sin^{2}(\pi y/M)$ is a discretised reading of the amplitude rather than the amplitude.

   approximationassumption

A scalar estimate with a stated additive-error guarantee, plus the shot or query budget and the maximum circuit depth actually consumed.

• Prepare an input state runs M iterations, M = O(1/ε), each running the preparation forwards and backwards once

  Map $|0\ldots0⟩$ to a state whose amplitudes are proportional to a specified vector $b$, to within $\varepsilon$. The cost is set by which description of $b$ you hold, not by the algorithm that consumes it.

  The loop stays coherent: nothing is measured between turns. The preparation may still be reapplied every turn — what the loop never pays is a readout and a restart from classical data. The price is depth, and a success probability that multiplies down the chain. The same slot as the row above, repeated the same way, and it is the closure that separates them: Brassard, Høyer, Mosca and Tapp's Theorem 12 uses exactly M iterations of the Grover operator, and one iteration runs A once forwards and once backwards. Nothing is measured until the end, so the ε^-2 of independent sampling becomes ε^-1. The bill does not vanish, it moves: those M applications are sequential, so the count is also a depth, and a device with a capped coherent depth cannot spend it — which is exactly what the contested note below is about.

  Amplitude estimation invokes the state-preparation unitary $\mathcal{A}$ exactly once on its own, to build the algorithm's input state, initializing two registers to $|0\rangle\mathcal{A}|0\rangle$. After that, $\mathcal{A}$ is reached only through the Grover iterate $\mathbf{Q} = -\mathcal{A}\mathbf{S}_{0}\mathcal{A}^{-1}\mathbf{S}_{\chi}$, applied as $\Lambda_{M}(\mathbf{Q}): |j\rangle|y\rangle \mapsto |j\rangle(\mathbf{Q}^{j}|y\rangle)$ for $0 \leq j < M$, so $\mathcal{A}$ and its inverse each execute once per application of the iterate, never in isolation and never with a measurement in between. assumption: $\mathbf{Q}$ is well-defined only because $\mathcal{A}$ is assumed to use no measurements and therefore possesses an inverse — the ingredient must hand back a coherent, uncomputing circuit, not a re-run-and-discard black box. What comes back is not a sampled bit but an estimate of $a$, the probability that measuring $\mathcal{A}|0\rangle$ would have produced a good element.

  assumption

given  coherent, controlled access to the state-preparation unitary A and to
       its inverse, and a bound on the observable's eigenvalues or on its
       tail distribution

encode the expectation value into an amplitude

form the Grover operator   Q = - A S_0 A^-1 S_chi
    # the global minus is Brassard, Hoyer, Mosca and Tapp's definition, and
    # it is what fixes the eigenphase convention the amplitude is read off
    # from

run M = O(1/e) iterations, coherently -- phase estimation on Q, or one of
    the QPE-free variants
    # each iteration runs the preparation forwards and backwards once

return the amplitude, hence the expectation value

# a state that has been prepared and measured cannot be reused, so this is
# the fault-tolerant-regime readout and direct sampling is the near-term one

Brassard, Høyer, Mosca and Tapp's Theorem 12 outputs $ã$ with $|ã − a| \leq 2\pi√(a(1−a))/M + \pi²/M²$ at probability at least $8/\pi²$, using exactly $M$ iterations, where one iteration runs $A$ once forwards and once backwards and evaluates $χ$ once. Knill, Ortiz and Somma give explicit algorithms that approach precision $1/N$ with $N$ uses, given a bound on the eigenvalues of the operators or on their tail distribution.

Reaching additive error $\varepsilon$ takes of order $1/\varepsilon$ sequential applications of $Q$, and that is a depth as much as a count, so a device with a capped coherent depth cannot spend it. Giurgica-Tiron, Kerenidis, Labib, Prakash and Zeng give two algorithms — Power law AE and QoPrime AE — carrying a parameter $\beta ∈ (0,1]$ with $N = \tilde{O}(1/\varepsilon^{1+\beta})$ oracle calls and $D = O(1/\varepsilon^{1−\beta})$ sequential calls, so $N·D = \tilde{O}(1/\varepsilon²)$ throughout and $\beta = 1$ recovers classical sampling. A quoted "quadratic speedup" that does not state the depth it assumes has not stated its cost.

• The qiskit-algorithms amplitude estimators

  • Quantum Amplitude Amplification and Estimation

    Gilles Brassard, Peter Hoyer, Michele Mosca, Alain Tapp · 2000

  About

  `qiskit_algorithms.amplitude_estimators`, the amplitude-estimation module of `qiskit-algorithms` — a Python package in the `qiskit-community` GitHub organisation, installed with `pip install qiskit-algorithms` and distributed on PyPI separately from Qiskit itself. It ships four estimators behind one `AmplitudeEstimator` base class, and they divide one against three. `AmplitudeEstimation` is the phase-estimation route: `ae.py`'s module docstring is "The Quantum Phase Estimation-based Amplitude Estimation algorithm", and the class docstring says it "implements the original Quantum Amplitude Estimation (QAE) algorithm, introduced by [1]. This canonical version uses quantum phase estimation along with a set of $m$ additional evaluation qubits", where [1] is Brassard, Høyer, Mosca and Tapp. The other three replace that evaluation register with repeated applications of the Grover operator, and each draws its own contrast with that same paper — but not all three draw it on phase estimation. `IterativeAmplitudeEstimation` does: it "differs from the original QAE algorithm proposed by Brassard [2] in that it does not rely on Quantum Phase Estimation, but is only based on Grover's algorithm". `MaximumLikelihoodAmplitudeEstimation` does too, calling itself "the quantum amplitude estimation (QAE) algorithm without phase estimation" and adding that "In comparison to the original QAE algorithm [2], this implementation relies solely on different powers of the Grover operator and does not require additional evaluation qubits". `FasterAmplitudeEstimation` does not: what `fae.py` says it does without, relative to that same paper, is qubits — "Due to the iterative version of the QPE, this algorithm does not require any additional qubits, as the originally proposed QAE [3] and thus the resulting circuits are less complex" — and "the iterative version of the QPE" is `fae.py`'s own name for its own mechanism. The README carries a warning that belongs beside any recommendation of the package: "**Qiskit Algorithms is no longer officially supported by IBM**. Like any other Apache 2 licensed code, you are free to use it or/and extend it, but please be aware that it is under your own risk."

  Methods

  Where $Q$ comes from is the part to check against this record's `conditions`. If the caller supplies no Grover operator, `EstimationProblem.grover_operator` builds one: it assembles a phase oracle over the `objective_qubits` — an `H` on the last of them, a multi-controlled `X` with the others as controls and that one as target, and an `H` again, collapsing to `H`, `X`, `H` when there is a single objective qubit — and passes it with the state preparation to Qiskit's own `grover_operator` function, or to the `GroverOperator` class below Qiskit 2.1.0. That function's docstring writes the operator with no global sign, $\mathcal{Q} = \mathcal{A} \mathcal{S}_0 \mathcal{A}^\dagger \mathcal{S}_f$, using $\mathcal{S}_f$ where this record writes $S_{\chi}$, $\mathcal{A}^\dagger$ where it writes $A^{-1}$, and — the substitution it is easy to stop one symbol short of — a zero reflection of the opposite sign. Qiskit's $\mathcal{S}_0$ is "usually defined as" $2 |0\rangle^{\otimes n} \langle 0|^{\otimes n} - \mathbb{I}_n$, while Brassard, Høyer, Mosca and Tapp's $\mathbf{S}_0$ "changes the sign of the amplitude if and only if the state is the zero state $|0\rangle$", which is its negative. With that third substitution written down, the two formulas name the same unitary, and the circuit that is built satisfies both. The code carries the sign the same way the notation does: the default zero reflection is `X` gates around a multi-controlled `Z`, chosen because it "can simply be implemented with a multi-controlled Z sandwiched by X gates on the target qubit and the introduced global phase does not matter for Grover's algorithm", and what that builds is $\mathbb{I} - 2|0\rangle\langle 0|$, the negative of Qiskit's $\mathcal{S}_0$; the last statement before the return, `circuit.global_phase = numpy.pi` under the one-line comment `# minus sign`, cancels that negative rather than introducing one, putting the built circuit onto the docstring's own formula. The `GroverOperator` class does the same at its own end. So a reader holding this record beside Qiskit's source has one operator written down twice, not a discrepancy to resolve, and the eigenphase convention `conditions` cares about survives the change of notation. `AmplitudeEstimation` then constructs the estimation circuit by composing the state preparation onto the qubits above the $m$ evaluation qubits and composing `qiskit.circuit.library.PhaseEstimation(m, grover_operator)` over the whole register — the source's own comment on that line is that the library circuit "does not include the A operator" — and, when called with `measurement=True`, measuring the $m$ evaluation qubits into an $m$-bit classical register. `num_eval_qubits` is that $m$, and the class stores `M = 2**num_eval_qubits`, so its `M` is a grid size rather than a qubit count: each measured integer $y$ becomes `np.round(np.power(np.sin(y * np.pi / 2**self._m), 2), decimals=7)`, the docstring's grid $\tilde{a} \in \{\sin^2(\pi y / 2^m) : y = 0, ..., 2^{m-1}\}$, which is this record's $\tilde{a} = \sin^2(\pi y/M)$ written with $M = 2^m$. The class also ships a way past that grid — "Using a maximum likelihood post processing, this grid constraint can be circumvented. This improved estimator is implemented as well" — and `estimate` runs both on every call, returning the most probable on-grid sample as `estimation` and the off-grid likelihood maximiser as `mle`, together with a confidence interval, whose `compute_confidence_interval` defaults to `alpha=0.05` and `kind="likelihood_ratio"` and also accepts `"fisher"` and `"observed_fisher"`, and a query count recorded as `result.num_oracle_queries = result.shots * (self._M - 1)`. One restriction is stated in the class docstring rather than left to the caller: "This class does not support the `.EstimationProblem.is_good_state` property, as for phase estimation-based QAE, the oracle that identifies the good states must be encoded in the Grover operator". `estimate` warns when one is set, and the warning states the fallback together with the condition it holds under: "For this algorithm, a custom oracle has to be encoded directly in the grover_operator. If no custom oracle is set, this algorithm identifies good states as those, where all objective qubits are in state 1." A caller who did supply a Grover operator — the case the paragraph above starts from — keeps whatever good states that oracle marks. The three siblings replace the evaluation register with repetition, and each says so where a caller meets it. `IterativeAmplitudeEstimation(epsilon_target, alpha, confint_method="beta", min_ratio=2)` "does not rely on Quantum Phase Estimation, but is only based on Grover's algorithm"; its class docstring states the guarantee with the confidence level written as $1 - \alpha$, its constructor docstring restates it as an estimate "that with at least probability 1 - alpha has an error of epsilon" and prices it as "The number of A operator calls scales linearly in 1/epsilon (up to a logarithmic factor)", and each round's interval comes from the Clopper-Pearson (`"beta"`, the default) or the Chernoff (`"chernoff"`) construction. `MaximumLikelihoodAmplitudeEstimation(evaluation_schedule)` "relies solely on different powers of the Grover operator and does not require additional evaluation qubits", and the schedule is those powers: a list of them, or an integer for which the exponential schedule `[id, Q^2^0, ..., Q^2^(evaluation_schedule-1)]` is used. `FasterAmplitudeEstimation(delta, maxiter, rescale=True)` documents `maxiter` as "The number of iterations, the maximal power of Q is `2 ** (maxiter - 1)`".

  Data

  The repository's own test file, `test/test_amplitude_estimators.py`, and only that: this module has no tutorial notebook of its own, the eleven in `docs/tutorials` running from `01_algorithms_introduction` to `13_trotterQRTE` with no amplitude-estimation entry among them. Two state preparations are defined in that test file and shared by all four estimators. `BernoulliStateIn(probability)` is a one-qubit circuit applying `RY(2 arcsin(sqrt(p)))` to prepare $\sqrt{1 - p}|0\rangle + \sqrt{p}|1\rangle$, used at $p = 0.2$, $0.49$, $0.12$, $0.5$ and $0.8$, and paired in several tests with a hand-written `BernoulliGrover(probability)` that declares `global_phase=np.pi` in its own constructor and overrides `power` so that a power of the operator costs one rotation. `SineIntegral(num_qubits)` is documented as a circuit that will "Construct the A operator to approximate the integral $\int_0^1 \sin^2(x) d x$ with a specified number of qubits" — Hadamards on an $n$-qubit state register, then one `RY` and $n$ controlled `RY`s onto a single objective qubit — and is used at $n = 2$, $3$ and $4$. The shot count is set on the sampler and takes the values 1, 100, 10,000, 100,000 and 1,000,000 across the tests, at seed 42 in the Bernoulli and sine-integral test classes and seed 2 in the Faster-AE one.

  Code

  `qiskit_algorithms/amplitude_estimators/` in https://github.com/qiskit-community/qiskit-algorithms — Python, Apache License 2.0, with headers reading "(C) Copyright IBM 2018, 2026" on `ae.py` and "(C) Copyright IBM 2020, 2023" on the package `__init__.py`. Eight files: `ae.py` for the canonical QPE-based estimator, `iae.py`, `mlae.py` and `fae.py` for the three siblings that carry no evaluation register, `estimation_problem.py` for the `EstimationProblem` input object and the default Grover-operator construction, `amplitude_estimator.py` for the base class and result object, `ae_utils.py` for the likelihood machinery `compute_mle` calls, and `__init__.py`, whose docstring is "The Amplitude Estimators package." and whose `__all__` names the four estimators, their result objects, the base class and `EstimationProblem`. Every estimator takes a Qiskit `BaseSamplerV2` primitive and an optional `transpiler`; `AmplitudeEstimation.estimate` warns and falls back to `StatevectorSampler` when no sampler was given. On PyPI the distribution is `qiskit-algorithms` ("Qiskit Algorithms: A library of quantum computing algorithms"), Apache-2.0, requiring Python >= 3.9, with seven releases of which 0.4.0 was uploaded 2025-08-29. Everything above was read from `main`; this entry does not claim a release version.

  Results

  Everything in `test/test_amplitude_estimators.py` runs on `qiskit.primitives.StatevectorSampler`; that file imports no other backend or simulator, so nothing recorded here is a hardware run. On the Bernoulli target the assertions pin the grid: `AmplitudeEstimation(2)` at $p = 0.2$ with 100,000 shots is asserted to return `estimation` 0.5 and `mle` 0.2, and `AmplitudeEstimation(3)` at $p = 0.49$ with 1,000,000 shots to return `estimation` 0.5 and `mle` 0.49 — the on-grid answer 0.5 in both cases, the maximum-likelihood post-processing recovering the input, both to `places=3`. On the sine integral, where $n$ is the argument to `SineIntegral(n)`, `AmplitudeEstimation(2)` at $n = 2$ with 1,000,000 shots is asserted to return `estimation` 0.5 and `mle` 0.2702, while the three siblings are asserted to return 0.2725 for `MaximumLikelihoodAmplitudeEstimation(4)` at $n = 4$, 0.2721 for `IterativeAmplitudeEstimation(0.1, 0.1)` at $n = 3$, and 0.2721 for `FasterAmplitudeEstimation(0.01, 6)` at $n = 3$ from a sampler given one shot, since "Number of shots for Sampler is not used in FasterAmplitudeEstimation". The confidence intervals are pinned as numbers too, at $n = 3$, 100 shots and $\alpha = 0.01$: around `AmplitudeEstimation(3)`'s `mle` they are (0.2494734, 0.3003771) by likelihood ratio, (0.2486176, 0.2999286) by Fisher and (0.2484562, 0.3000900) by observed Fisher, and the test also asserts the estimate lies inside each — but the assertion guarding the endpoints is `np.testing.assert_array_almost_equal(..., decimal=1)`, so the seven digits are a note of what came out rather than what is checked. Three tests check the construction instead of the estimate: `test_qae_circuit`, `test_iqae_circuits` and `test_mlae_circuits` build the circuits by hand and assert `Operator` equality against what the classes produce. The canonical circuit is checked at $m = 2$ and $m = 5$ evaluation qubits, and the other two at $k = 2$ and $k = 5$ — but that $k$ is not the same quantity in both. In `test_iqae_circuits` it goes to `construct_circuit(problem, k, ...)`, whose own argument documentation reads "k: The power of the Q operator". In `test_mlae_circuits` it goes to the constructor as `evaluation_schedule`, which `mlae.py` expands to `[0] + [2**j for j in range(evaluation_schedule)]`, so $k = 5$ there is a schedule of six circuits at powers 0, 1, 2, 4, 8 and 16, and the largest power of $Q$ built is 16 rather than 5. The test's own manual build says the same, looping `for power in range(k)` over `circuit.ry(2 * 2**power * angle, ...)`.

• Quantum amplitude estimation · Qiskit

  From the repository — run, not written up from a paper · native

  About

  A finance- and Monte-Carlo-facing primitive that makes the oracle and error model visible.

  Methods

  None found yet.

  Data

  None found yet.

  Code

  Qiskit

  Results

  Bernoulli toy estimator checked · oracle assumptions explicit

• Quantum amplitude estimation

  A finance- and Monte-Carlo-facing primitive that makes the oracle and error model visible.