Iterative phase estimation on one ancilla

What it fills

• Estimate the eigenphase of a unitary

  Given a circuit whose controlled powers you can apply, and a routine preparing a state with non-negligible overlap on one of its eigenvectors, return that eigenvector's phase as a number with an error bar. The phase is read out of an ancilla, never out of the system register — the system is only ever the thing the controlled powers act on.

When it applies

Dobsicek et al. state the size claim in the abstract — an iterative phase estimation "with a single ancillary qubit" — and make explicit that the qubit count does not grow with the precision: "The minimal system for implementing the iterative PEA is a two qubit system, where one qubit is a read-out ancilla, and the second qubit represents a physical system." The order of the rounds is part of the method rather than an implementation detail: "first less significant digits are evaluated and then the obtained information improves the quantum part of the search for more significant digits", carried by "an extra single qubit Z-rotation that is inserted into the circuit" whose angle is a function of the bits already measured — $\omega_k = -2\pi(0.0x_{k+1}x_{k+2} \ldots x_m)$, with $\omega_m = 0$. Nothing quantum passes between rounds; the feedback is a classically computed angle.

Requires

Every step this method names moves its route along, so there is nothing it needs alongside them.

Example

given  a circuit for controlled-U^(2^(k-1)), an EIGENSTATE |Psi> of U with
       U|Psi> = e^(i*2*pi*phi)|Psi>, the number of bits m wanted of phi,
       and ONE ancilla qubit that is reused every round -- not m of them
                                            (Abstract; Iterative PEA, Fig. 1)
    # the whole derivation below is set on a fixed eigenstate: the paper
    #   initialises "the lower line register to an eigenstate |Psi> of the
    #   operator U" and never treats any other input. It says NOTHING about
    #   feeding in a superposition, so nothing here should be read as a
    #   guarantee for one                                    (Iterative PEA)

requires  nothing quantum survives between rounds: the ancilla is measured
    and reset each round, and what carries forward to round k is only the
    classical bit string x_{k+1} .. x_m already measured. This is the
    semiclassical-QFT substitution -- the paper calls the method the
    "single ancilla QFT based PEA", citing the semiclassical QFT
                                                 (Introduction, Ref. 18)

# --- round k, run for k = m, m-1, ..., 1 -- LEAST significant bit first ----
# "Note that k is iterated backwards from m to 1."        (Iterative PEA,
#                                          body text, just before Fig. 2)
for k = m downto 1:
    ancilla <- |0>                    # fresh each round; system reg keeps |Psi>
    H on ancilla
    apply controlled-U^(2^(k-1)), ancilla as control                 (Fig. 2)
        # k = m, the FIRST round executed, applies controlled-U^(2^(m-1))
        #   and yields the LEAST significant bit             (Iterative PEA)
    omega_k = -2*pi * (0.0 x_{k+1} x_{k+2} ... x_m)             (Fig. 2 caption)
        # binary fraction built ONLY from bits already measured this run;
        #   omega_m = 0 by definition -- round m has nothing to feed back yet
    Rz(omega_k) on ancilla                                          (Fig. 2)
        # this rotation IS the algorithm: "the information transfer is done
        #   with an extra single qubit Z-rotation that is inserted into the
        #   circuit", in place of the QFT register       (Iterative PEA)
    H on ancilla
    measure ancilla -> x_k                                          (Fig. 2)
        # the paper builds the success probabilities CONDITIONALLY: "if
        #   phi_m was measured correctly, the probability to measure
        #   phi_{m-1} in the second iteration is cos^2(pi*delta/4)", and so
        #   on. So P_k below is conditional on every earlier (higher-k) bit
        #   being right; a wrong x_k enters omega for every round still to
        #   come                                     (Iterative PEA, pre-Eq. 1)

return  phi-tilde = 0.x_1 x_2 ... x_m, m bits total, one measurement each

# --- when the bits are exact -------------------------------------------
# assume phi = 0.phi_1 phi_2 ... phi_m 000... , i.e. an exact binary
#   expansion of at most m bits. Then at round k the probability of
#   outcome "0" is P0 = cos^2[pi*(0.phi_k 0 0 ...)], which is 1 for
#   phi_k = 0 and 0 for phi_k = 1, so every bit is extracted
#   DETERMINISTICALLY                         (Iterative PEA, before Eq. 1)

# --- when they are not: phi = phi-tilde + delta*2^-m, 0 <= delta < 1 ----
# P_k = cos^2(pi * 2^(k-m-1) * delta)    # conditional, per round     (Eq. 1)
# P(delta) = prod_{k=1..m} P_k = sin^2(pi*delta) / (2^(2*m) * sin^2(pi*2^-m*delta))
#   -- "the same outcome probability as the textbook phase estimation,
#      based on the QFT"                                            (Eq. 1)
# P_k is smallest at k = m (the first round executed, least significant
#   bit) and approaches 1 as k -> 1, which is why the error is dominated
#   by the least significant bits                            (post-Eq. 1)
# P(delta) decreases monotonically in m; the bounds below are the
#   m -> infinity limit, NOT finite-m values                  (post-Eq. 1)
#   - best rounding only (error < 2^-(m+1)): lower bound P(1/2) = 4/pi^2
#   - accepting BOTH phi-tilde and phi-tilde + 2^-m (accuracy 2^-m):
#     success P(delta) + P(1-delta), lower bound 8/pi^2, hence error
#     probability epsilon < 1 - 8/pi^2, independent of m       (post-Eq. 1)

# --- optional: cut epsilon by repeating only the least significant bits --
# repeat the measurement of only the first few bits (large k) a limited
#   number of times and take a simple majority vote; O(log^2(1/epsilon))
#   extra measurements suffice for error below epsilon, independently of m.
#   Repeating ALL m bits is called "unnecessarily expensive" for single
#   systems such as superconducting qubits    (Iterative PEA, closing para.)
# the alternative -- run m' = m + log(2 + 1/(2*epsilon)) rounds and keep the
#   m most significant bits -- is available too, but the paper rejects it
#   here because "implementing the U^(2^k) gate for large k is the
#   algorithm's bottleneck in a realistically noisy environment"
#                                             (Iterative PEA, after Eq. 1)

# --- cost note, not part of the construction above -----------------------
# m rounds, m measurements -- one per round. Against Kitaev's PEA, "each
#   bit has to be measured only once, compared to log(m) times", and
#   Kitaev's is "always probabilistic" where this one is deterministic
#   for an exact m-bit phase                                 (Introduction)
# depth is the price: "each round requires exponentially many applications
#   of U, unless powers U^(2^k) are available by different means"
#                                                            (Introduction)
# what this method demonstrably saves is the m-1 extra ancillas of the
#   textbook m-ancilla work register. Whether the TOTAL number of U
#   applications is equal to the register version's is NOT a comparison
#   this paper makes -- it is left unclaimed here rather than asserted

# NOT covered above, deliberately: the two-qubit superconducting benchmark
#   realization (ZZ-gate, Fig. 3) and the gate-noise / dephasing robustness
#   analysis (Eqs. 2-4, Figs. 4-5). Those are one hardware instance, not
#   part of the general construction.

Cost, as the source states it

Dobsicek et al. price the noiseless protocol exactly: one ancilla and $m$ rounds buy $m$ bits of the eigenphase $\phi$ of $\hat U$, i.e. accuracy $1/2^m$, at one measurement per round -- $m$ measurements in all, where Kitaev's PEA measures each bit $\log(m)$ times. Extraction is deterministic when $\phi$'s binary expansion is at most $m$ bits; otherwise the success probability never falls below $8/\pi^2$, so the error probability satisfies $\varepsilon<1-8/\pi^2$ independently of $m$, and $O[\log^2(1/\varepsilon)]$ extra measurements push it below any $\varepsilon$, again independently of $m$. The price is depth: round $k$ applies controlled-$\hat U^{2^{k-1}}$, exponentially many uses of $\hat U$ unless that power is available by other means -- the paper's named bottleneck under realistic noise. On their own two-qubit superconducting benchmark it is free (one ZZ-gate plus three single-qubit gates), and simulated dephasing at $0.01<\Gamma_\varphi/\lambda<0.1$ (rate over qubit-qubit coupling) gives 5-8 bits in under $10^4$ measurements at $\varepsilon<0.05$.

Implementations

• Qiskit's `IterativePhaseEstimation` class

  • Arbitrary accuracy iterative phase estimation algorithm as a two qubit benchmark

  The class docstring names its source directly: "Run the Iterative quantum phase estimation (QPE) algorithm. Given a unitary circuit and a circuit preparing an eigenstate, return the phase of the eigenvalue as a number in [0,1) using the iterative phase estimation algorithm," citing "[1]: Dobsicek et al. (2006), Arbitrary accuracy iterative phase estimation algorithm as a two qubit benchmark" by name -- the same paper this record's own theory and cost fields are drawn from, not a different phase-estimation reference.

  `IterativePhaseEstimation.__init__` takes `num_iterations` (the round count $m$) and a `BaseSamplerV2` sampler, raising `AlgorithmError` if no sampler is supplied. `_estimate_phase_iteratively` loops `for k in range(self._num_iterations, 0, -1)` -- $m$ down to 1 -- halving a running `omega_coef` before building each round's circuit, so the feedback angle is reconstructed bit by bit rather than passed in as a closed form. Each round's circuit (`construct_circuit`) allocates a fresh one-qubit `phase_register` (`QuantumRegister(1, name="a")`) and a fresh one-bit `ClassicalRegister`, applies a Hadamard to the phase register, composes `unitary.power(2 ** (k - 1)).control()` into the eigenstate register, applies `qc.p(omega, phase_register[0])`, a second Hadamard, then measures -- each round is built and submitted to the sampler as its own independent circuit, using only one ancilla qubit at a time rather than $m$ simultaneously. After each measurement `x`, `omega_coef = omega_coef + x / 2` before the next round's halving, which is the paper's classical-only feedback: no quantum state carries between rounds.

  No dataset. `unitary` and `state_preparation` are supplied by the caller as `QuantumCircuit` objects. The package's own test suite (`test/test_phase_estimator.py`, class `TestPhaseEstimation`) exercises four single- and two-qubit eigenproblems -- Pauli Z, Pauli X, an $R_z(\pi/2)$ rotation, and T$\otimes$T -- prepared in known eigenstates with X, I, H, or no gates.

  `qiskit_algorithms/phase_estimators/ipe.py` in https://github.com/qiskit-community/qiskit-algorithms -- Python, Apache License 2.0, header "(C) Copyright IBM 2021, 2026". Class `IterativePhaseEstimation`, re-exported at the package's top level (`qiskit_algorithms/__init__.py`) alongside the register-based `PhaseEstimation` in the same `phase_estimators` subpackage. Distributed on PyPI as `qiskit-algorithms` 0.4.0 (uploaded 2025-08-29, seven releases total), Apache-2.0, requiring Python >= 3.9. The repository's README carries a standing warning: "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." Read from `main`; this entry does not claim a release-tag diff.

  The package's own test suite runs `IterativePhaseEstimation(num_iterations=6, sampler=StatevectorSampler(seed=42))` -- Qiskit's noiseless statevector-simulator sampler -- against single- and two-qubit unitaries with known eigenstates, asserting the returned `.phase` equals the exact expected value (`assertEqual`, no tolerance): 0.5 for a Z unitary on an X-prepared eigenstate and 0.0 on the default all-zero state (`test_qpe_Z_sampler`); 0.0 and 0.5 for an X unitary on H- and H-then-Z-prepared eigenstates (`test_qpe_X_plus_minus_sampler`); 0.125 and 0.875 for an $R_z(\pi/2)$ unitary (`test_qpe_RZ_sampler`); and 0.25 and 0.125 for a two-qubit T$\otimes$T unitary (`test_qpe_two_qubit_unitary`) -- all phases with an exact binary expansion of 6 bits or fewer, matching the paper's deterministic-extraction case rather than its probabilistic one.

What it needs

Nobody has taken this apart yet. That is a gap in this graph, not a claim that the method has no parts.

Other ways to fill the same slot

Different approaches

• Phase estimation into an ancilla register

  Put a register of ancillas into superposition, apply controlled U raised to each power of two into it, and let the phase accumulate across the register. The register then holds the phase in the Fourier basis, and one transform back turns it into bits you can measure.

In the Atlas

• Iterative phase estimation

  Estimates the eigenphase of a unitary using a single reused ancilla qubit instead of a full phase-estimation register.

Sources

• Arbitrary accuracy iterative phase estimation algorithm as a two qubit benchmark↗M. Dobsicek, G. Johansson, V. S. Shumeiko, G. Wendin · 2006theory yes · simulation ? · hardware no