Coherent amplitude-estimation readout

What it fills

• Estimate an observable

  Given the ability to prepare $|ψ⟩$ and a description of an observable $O$, return a classical scalar within $\varepsilon$ of $⟨O⟩$ at confidence $1−δ$. The state is never returned; only the number is.

When it applies

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.

Requires

These do not move the route along. The method needs each of them alongside its own work, and the cost of getting them is part of what the method costs.

• 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

Example

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

Cost, as the source states it

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.

Implementations

• The qiskit-algorithms amplitude estimators

  • Quantum Amplitude Amplification and Estimation

  `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."

  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)`".

  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.

  `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.

  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, ...)`.

What it needs

Every step this method names is listed under Requires above. It walks its own span in one hop and calls out to the rest — that is a fact about the recorded route, not a claim that the span is simple.

Other ways to fill the same slot

Different approaches

• Direct sampling in a measurement basis

  Decompose $O$ into Pauli strings, rotate each into the computational basis with a layer of single-qubit Cliffords, sample bitstrings, and recombine the per-term averages linearly. No ancilla, no controlled operations, minimum added depth.

• Classical shadow readout

  Apply a random unitary from a chosen ensemble, measure in the computational basis, and keep the (unitary, outcome) pair; inverting the measurement channel turns each pair into an unbiased single-shot snapshot of $ρ$, and median-of-means over snapshots predicts many observables at once. The observables may be chosen after the data has been taken.

• Measure commuting terms together

  A Hamiltonian's terms are measured one group at a time rather than one term at a time. Terms that commute qubit-wise can share a single set of measurements, so the question becomes how few groups the terms can be covered by — a graph problem, and a hard one.

In the Atlas

• Quantum amplitude estimation

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

Sources

• Quantum Amplitude Amplification and Estimation↗Gilles Brassard, Peter Hoyer, Michele Mosca, Alain Tapp · 2000theory yes · simulation ? · hardware no
• Optimal Quantum Measurements of Expectation Values of Observables↗Emanuel Knill, Gerardo Ortiz, Rolando D. Somma · 2006theory yes · simulation ? · hardware no
• Low depth algorithms for quantum amplitude estimation↗Tudor Giurgica-Tiron, Iordanis Kerenidis, Farrokh Labib, Anupam Prakash, William Zeng · 2020theory yes · simulation yes · hardware no