MethodLayer 2
Variable-time amplification
When the branches of the amplified routine stop at different times, amplify in nested stages so branches that finish early are not charged at the worst-case depth.
The preparation unitary and its inverse, a reflection about , and a reflection marking the good subspace — the Grover operator must be applicable at arbitrary powers. Individual variants additionally require a lower bound on , or a per-branch stopping flag.
A routine that produces the wanted branch with a stated failure probability, together with the query count and the maximum sequential depth consumed.
Same contract as the slot it fills.
This one, drawn
From Routine with a good branch to Reliable routine
A circle is an object you are holding. This method is drawn heavier, opened into its own steps; the other lines between the same two ends are the alternatives recorded for the same slot. Circles are named on hover, and each one is a link.
Nothing drawn here has a recorded way through it that this figure leaves shut. See it on the map
What it fills
- Amplify a success branch
Take a routine whose output lands in the wanted subspace only with probability , and raise that probability to near 1 using quadratically fewer repetitions than restarting the routine would need.
When it applies
Requires the amplified algorithm to decompose into stages carrying a per-branch stopping flag; a routine with a single uniform stopping time gains nothing from it. Its natural position is above a solver whose branches differ in cost — which is where the dependence of a linear-system solve actually lives — rather than above a bare preparation.
Requires
Every step this method names moves its route along, so there is nothing it needs alongside them.
Example
given the routine to be amplified, decomposed into stages that carry a
per-branch stopping flag; and A, its inverse, the reflection S_0
about |0> and the reflection S_chi marking the good subspace
# a routine with a single uniform stopping time gains nothing from this
amplify in nested stages, so that branches which finish early are not
charged at the worst-case depth
# how the stages nest is not stated on this record and is not invented here
return the wanted branch with a stated failure probability, together with
the query count and the maximum sequential depth consumed
# the depth is the line to read: it is the resource a coherence-limited
# device actually runs out of first
# its natural position is above a solver whose branches differ in cost --
# which is where the kappa dependence of a linear-system solve actually
# lives -- rather than above a bare preparation
# Ambainis generalizes amplitude amplification to the case when parts of the
# algorithm being amplified stop at different times, improving the Harrow
# et al. linear-systems running time from O(kappa^2 log N) to
# O(kappa log^3 kappa log N), kappa the condition number of the system
# Chakraborty, Gilyen and Jeffery build variable-time amplitude estimation
# directly on this techniqueCost, as the source states it
Ambainis states his generalization of amplitude amplification "to the case when parts of the quantum algorithm that is being amplified stop at different times" improves the running time of the Harrow et al. linear-systems algorithm "from O(kappa^2 log N) to O(kappa log^3 kappa log N) where kappa is the condition number of the system of equations". Chakraborty, Gilyén and Jeffery build on it directly: they "develop a technique of variable-time amplitude estimation, based on Ambainis' variable-time amplitude amplification technique".
Implementations
No standalone implementation of Ambainis's variable-time amplitude amplification was found, and the two general amplitude-amplification libraries checked for its natural home -- a variable-time quantum linear-system solver -- do not carry it either. Qualtran (quantumlib/Qualtran, commit 096a2d0, fetched 2026-08-26) has no amplitude-amplification bloq of any kind: a recursive listing of the full repository tree (1240 paths, not truncated) contains zero paths matching 'amplitude', 'amplify', 'grover', 'variable_time' or 'hhl'. pyLIQTR (isi-usc-edu/pyLIQTR, commit 0465e1d, fetched 2026-08-26) shows the same absence: its recursive tree (500 paths, not truncated) has no amplitude-amplification, Grover, or variable-time file; every 'amp' match is the unrelated substring in 'Examples' or 'example'. Two libraries that do implement a variable-time quantum linear-system solver implement a different one, not Ambainis's: Eclipse Qrisp shipped Childs-Kothari-Somma's algorithm in v0.8 as a standalone module (its own changelog: 'It uses LCU with qubitization and a Chebyshev polynomial approximation of 1/x'), which is a route to the exponentially-improved-precision result that does not go through variable-time amplitude amplification at all -- 'Ambainis' and 'variable time' appear nowhere in Qrisp's 1581-file tree. Classiq's HHL tutorial notebook cites Ambainis's paper only as background prose in a Technical Notes cell ('Ambainis introduced a generalization of amplitude amplification, which allows reducing the quadratic kappa dependence to linear'); the notebook's own circuit runs textbook QPE-based HHL with plain postselection over repeated measurement shots -- amplitude amplification, ordinary or variable-time, is not invoked anywhere in the notebook's code, only named in the Technical Notes cell as a possible, unimplemented speedup. Two more repositories name-check the technique but do not build it: tsotchke/quantum_geometric_tensor (450-star C library, commit 770994a) declares a `use_variable_time` boolean in its `amp_config_t` struct and lists 'Variable time amplitude amplification' among the header's stated Applications, but the flag is set to `false` in the one default-config line that mentions it and is never read or branched on anywhere else in the 888-line implementation file -- unlike the adjacent `fixed_point` flag, which does drive real code (`compute_fixed_point_angles`, `amp_run_fixed_point`). xpclove/qblas (commit 59ee43e) has a file named `q_svd_vartime.qs` whose header cites 'Variable-time amplitude estimation: Childs et al.', but `q_svd_vartime_core` is a plain loop of repeated phase-estimation calls at shrinking precision with no per-branch stopping flag and no nested amplification stage -- it does not implement the cited technique's mechanism, and the same repository's separate amplitude-amplification file cites a 'Zahournaded et al., "Interactive QAA" 2020' that could not be located anywhere else in a GitHub-wide code search, which is reason not to trust its other citations as accurate labels for what its code does. Variable-time amplitude amplification is a technique that lives inside other algorithms' proofs rather than as a library routine, and no artefact surfaced that actually runs it.
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
- Fixed-point amplification
Replace the reflections of textbook amplification with tuned phase shifts, so the iteration converges on the target instead of rotating past it — which is what happens when the initial success amplitude is known only as a lower bound.
In the Atlas
No record in the Atlas covers this yet. The catalogue is circuits and primitives; this part of the literature is not in it.