Iterative Quantum Algorithms (IQA)

• Iterative Quantum Algorithms (IQA) are a class of hybrid quantum-classical algorithms that iteratively use quantum measurements to guide classical problem reduction and update subsequent quantum routines.
• They employ a structured process involving preparation, selection, and reduction steps, with techniques such as adaptive Grover search and Krylov subspace refinement to boost convergence and efficiency.
• IQA methods strategically trade quantum resources for classical processing to achieve significant qubit savings and enhanced solution accuracy in complex optimization problems.

Searching arXiv for papers on Iterative Quantum Algorithms and closely related formulations. Iterative Quantum Algorithms (IQA) denotes a hybrid quantum-classical paradigm in which a quantum routine is executed on a current problem instance, measurement-derived information is classically processed, and that information is used to construct the next quantum instance, reduction rule, or update. In the formal treatments for Maximum Independent Set and quantum DPLL, the loop is organized as a preparation step, a selection step, and a reduction step; in other realizations, the same pattern appears as solution $\rightarrow$ classical basis update $\rightarrow$ new Hamiltonian $\rightarrow$ new quantum optimization, as shrinking-input Grover search, as sequential Krylov-subspace refinement, or as adaptive confidence-interval updates in amplitude estimation (Brady et al., 2023, Brady et al., 2 Sep 2025, Zhu et al., 2022, Mu et al., 2022, O'Leary et al., 2024, Grinko et al., 2019). The unifying feature is that the quantum subroutine is not required to solve the full problem in one shot; instead, it supplies information that changes the next instance.

1. Conceptual framework and defining characteristics

In the broadest formulation, IQA is a class of hybrid algorithms in which a quantum computer provides information that leads to a simplified problem for future iterations. One explicit definition gives three repeating steps: a preparation step, in which a quantum state is prepared and measured; a selection step, in which the measurement data are classically processed to choose a variable, correlator, clause, or term; and a reduction step, in which the problem is reduced and logical inference is applied before the next round (Brady et al., 2 Sep 2025). In the Maximum Independent Set formulation, the same structure is described as running a quantum subroutine on the current reduced problem, measuring observables, applying a classical reduction rule, and repeating until the instance becomes trivial, after which the reductions are reversed to obtain a solution (Brady et al., 2023).

A recurrent distinction in this literature is between true iteration and repeated execution of an unchanged circuit. Standard Grover search repeatedly applies amplitude amplification to the same input size, so the qubit count stays fixed; IQuCS instead reduces the dataset size iteratively and rebuilds the next quantum circuit on the reduced state space (Mu et al., 2022). IQOAP is even more explicit: the quantum output is directly used to reshape the Hamiltonian being optimized in the next round, rather than merely supplying a value to a loosely coupled classical post-processor (Zhu et al., 2022). This suggests that, within the IQA literature, “iterative” usually means that the subsequent quantum problem is itself modified.

The paradigm is broader than recursive QAOA-style elimination. It includes iterative basis improvement for lattice Hamiltonians, sequential subspace diagonalization, non-QPE amplitude estimation, iterative imaginary-time and power methods, block-encoding implementations of classical linear-system iterations, matrix Bregman-projection methods on Hermitian matrices, recursive QSP constructions, and iterative state-preparation schemes based on tensor decompositions (Zhu et al., 2022, O'Leary et al., 2024, Grinko et al., 2019, Kyaw et al., 2022, Liu et al., 2022, Ji, 2022, Gomes et al., 2024, Blank et al., 10 Feb 2026).

2. Adaptive reduction and instance reconstruction

A central IQA pattern is to use quantum information to simplify or reparameterize the next problem instance.

Method	Quantum information used	Classical update
IQOAP	low-lying lattice vector	basis replacement and new Hamiltonian
IQuCS	measured state fidelities	filtering of unlikely states and regeneration of dataset
MIS / quantum DPLL IQA	single-qubit expectations, correlators, or term expectations	variable fixing, hard-constraint promotion, and logical inference
SkS iterative QUBO relaxations	approximate QUBO solution	penalty or multiplier update

In IQOAP, the shortest vector problem is encoded by

$$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$

with each $\hat Q_i$ realized on $k$ qubits and therefore restricted to a finite integer spectrum. Because the encoded Hamiltonian is truncated, a poor lattice basis can place the true shortest vector outside the representable range. The algorithm starts from a bad basis, uses a quantum optimizer to find a low-lying lattice vector, checks whether that vector can replace a basis vector while preserving the lattice, updates the basis if possible, rebuilds the Hamiltonian, and repeats. In the reported 4D shortest-vector example, a basis update is usually possible after only $2$ to $10$ QAOA repetitions, and after $50$ iterations the actual shortest vector is found with high probability, about $82\%$ in the example shown; over $\rightarrow$0 randomly chosen $\rightarrow$1D lattices, the behavior is reported as similar (Zhu et al., 2022).

IQuCS applies the same logic to Grover-style index search. After each Grover execution, the classical side computes fidelities $\rightarrow$2 and removes candidates satisfying

$\rightarrow$3

with $\rightarrow$4 in the experiments. The reduced dataset is then reindexed and passed to the next quantum round. The paper introduces cumulative qubit consumption,

$\rightarrow$5

to measure iterative cost, and reports qubit-consumption reductions up to $\rightarrow$6 relative to an idealized Grover baseline, at the cost of threshold sensitivity and repeated recompilation overhead on current hardware (Mu et al., 2022).

For constrained combinatorial optimization, the reduction step is often intertwined with inference. In the generalized IQA framework for arbitrary $\rightarrow$7-local Hamiltonians,

$\rightarrow$8

a selected logical term can be elevated to a hard constraint,

$\rightarrow$9

and inference is then applied to deduce fixed variables, correlations, or implied term values. For a connected constraint sub-hypergraph with $\rightarrow$0 variables and $\rightarrow$1 satisfying strings, the reported inference runtime is worst-case $\rightarrow$2 and best-case $\rightarrow$3 (Brady et al., 2 Sep 2025). The quantum DPLL construction embeds this IQA logic inside a complete backtracking tree search: the quantum routine informs the branching rule, while unit propagation and pure literal elimination perform the classical simplification (Brady et al., 2 Sep 2025).

A related adaptive-instance strategy appears in the sparsest $\rightarrow$4-subgraph work, where outer loops repeatedly solve QUBO relaxations and update penalty parameters or multipliers until the constraint $\rightarrow$5 is met. QPIA increases $\rightarrow$6 when the cardinality is incorrect; LRIA updates $\rightarrow$7 with $\rightarrow$8; ALIA updates both $\rightarrow$9 and $$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$0 multiplicatively. The paper proves exactness thresholds for the relaxations, but states that convergence of the iterative heuristic algorithms is not proved because the inner QUBOs are solved only approximately (Bihani et al., 10 Sep 2025).

3. Sequential refinement of bases, subspaces, and states

Another major IQA family replaces one large quantum task by a sequence of smaller or better-conditioned ones.

Partitioned Quantum Subspace Expansion (PQSE) is an iterative generalisation of quantum subspace expansion in a Krylov basis. Instead of solving once in $$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$1, it partitions the total order into $$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$2 and solves a chain of subspace problems,

$$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$3

where each $$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$4 is the lowest-energy state from the previous step. The coefficients still come from the generalized eigenvalue problem

$$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$5

but the partitioned sequence is chosen by a variance-based criterion. For fixed maximal Krylov order, the paper states that the single-step and sequential versions require the same quantum resources, while the classical overhead scales as $$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$6 rather than the $$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$7 solve of standard QSE. Numerically, PQSE can reduce the relative energy error by up to three orders of magnitude compared with thresholded QSE in favorable regimes, and its instability mitigation is described as parameter-free (O'Leary et al., 2024).

MQITE implements a different form of sequential refinement. The key basis states are

$$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$8

with $$H_P=\sum_{ij=1}^d ({\bf b}_i{\bf b}_j)\,\hat Q_i \hat Q_j \, ,$$9 drawn from orthogonal computational-basis strings, so the expansion basis remains orthogonal after propagation. This removes the non-orthogonal linear-system solve required in earlier QITE schemes. The algorithm keeps only the dominant $\hat Q_i$0 bit strings measured from $\hat Q_i$1, and the paper argues that $\hat Q_i$2 can be kept polynomial in $\hat Q_i$3 by controlling the imaginary-time increment and the measurement precision. The gate count per imaginary-time step is estimated as

$\hat Q_i$4

and locality of the Hamiltonian is explicitly not required, which the paper identifies as useful for highly nonlocal systems such as the occupation-representation nuclear shell model (Jouzdani et al., 2022).

Iterative linear-algebra analogues also fall into this category. Quantum relaxed row and column iteration methods quantize classical relaxed Kaczmarz and coordinate-descent updates by realizing each iteration as a unitary block-encoding-style transformation. Assuming efficient preparation of row or column states, both algorithms have total cost $\hat Q_i$5 after $\hat Q_i$6 iterations, and neither requires phase estimation or Hamiltonian simulation (Liu et al., 2022).

Later work extends this iterative-refinement logic to state preparation. Q-Tucker alternates classical analysis of entanglement structure, selection of a tensor partition or mode ordering, and a local Tucker-style factorization step that updates a residual core state. With the monotone gauge, the reported fidelity sequence satisfies $\hat Q_i$7, and under a stall-and-grow strategy exact preparation $\hat Q_i$8 is reached when the block size is allowed to reach $\hat Q_i$9 (Blank et al., 10 Feb 2026).

4. Variational, estimation, projection, and recursive-synthesis schemes

Some of the most developed IQA instances do not reduce a combinatorial instance directly; instead, they iteratively refine an estimate, a variational state, or a matrix projection.

Iterative Quantum Amplitude Estimation (IQAE) replaces QPE-based amplitude estimation by an adaptive confidence-interval loop. For

$k$0

the algorithm repeatedly chooses a Grover power $k$1, measures the last qubit of $k$2, constructs a confidence interval for $k$3, and shrinks an interval $k$4. The paper proves that, with probability at least $k$5, the returned estimate satisfies $k$6, that the algorithm terminates after at most

$k$7

rounds, and that the oracle complexity scales as $k$8 up to confidence factors. The method avoids the QPE ancilla register, QFT, and controlled-$k$9 depth (Grinko et al., 2019).

Variational Quantum Iterative Power Algorithms (QIPA) represent a different iterative family. They use generalized positive oracle functions

$2$0

and, in the main experiments, the double exponential

$2$1

The variational parameters are updated through a McLachlan-type linear system $2$2, measured by Hadamard tests. The paper reports faster convergence than QITE in numerical experiments on $2$3 dissociation, transmon ground-state search, and biprime factorization (Kyaw et al., 2022). A later analysis of QIPA$2$4 argues, however, that the promised exponential separation from varQITE requires a highly restrictive spectral regime, that the required preprocessing $2$5 may itself need $2$6, and that the algorithmic error then blows up so strongly that the separation is not practically achievable; the same work nevertheless reports a small-instance polynomial enhancement on a $2$7-node MaxCut example with $2$8 on IBM hardware via Qiskit (Czégel et al., 8 Feb 2025).

Matrix Legendre-Bregman projection algorithms provide yet another iterative template. The update map is

$2$9

and the paper gives exact and approximate iterative projection algorithms on Hermitian matrices, supported by a general duality theorem and Pythagorean identity. In the Kullback-Leibler case, the framework yields non-commutative analogues of generalized iterative scaling and AdaBoost, while the quantum side can target the update state, constraint search, and Gibbs-state preparation via smooth function evaluation, two-phase quantum minimum finding, and NISQ Gibbs-state preparation (Ji, 2022).

At the circuit-synthesis level, iterated QSP treats QSP as a recursive primitive: one QSP-generated transformation is fed as the input signal to another QSP routine. The paper states an “Iterated SU(2) QSP” theorem and uses a squaring routine to synthesize multiplication of phase angles, bounded-degree multivariate polynomial phase functions, Coulomb-like kernels, and bosonic square-root couplings without reversible arithmetic, with several core subroutines scaling as

$10$0

queries (Gomes et al., 2024).

5. Resources, guarantees, and algorithmic tradeoffs

A recurring theme in IQA is the deliberate exchange of one resource for another. IQAE reduces qubit count and gate depth by removing QPE and replacing it with repeated one-qubit measurements plus classical confidence-interval processing, while preserving a rigorous accuracy guarantee (Grinko et al., 2019). PQSE keeps the same quantum measurement requirements as a full Krylov-space solve of the same maximal order, but exchanges a single large generalized eigenproblem for several smaller ones and accepts polynomially larger classical postprocessing (O'Leary et al., 2024). MQITE removes classical linear-system solves, but the paper explicitly notes that the present form is not yet NISQ-friendly because of circuit depth and measurement demands (Jouzdani et al., 2022).

In hardware-constrained search, IQuCS makes the tradeoff especially explicit. By shrinking the input size between Grover calls, it reduces qubit usage and cumulative qubit consumption, but it can miss true targets under aggressive thresholding, and repeated initialization and compilation overhead can dominate runtime on present IBM-Q hardware. The paper states that the method is heuristic and lacks a full theoretical performance bound (Mu et al., 2022).

Constraint-handling relaxations show a different tradeoff. In the sparsest $10$1-subgraph work, exactness thresholds are proved for quadratic-penalty, Lagrangian, and augmented-Lagrangian QUBO relaxations, but dense quadratic penalties create embedding bottlenecks on D-Wave hardware. LRIA is reported as more QPU-friendly because it keeps the QUBO sparse, whereas QPIA and ALIA often require clique embedding (Bihani et al., 10 Sep 2025).

The quantum/classical division of labor is therefore not incidental. In these algorithms, the quantum side is used for amplitude amplification, expectation estimation, moment acquisition, Gibbs-like updates, or low-depth state transformations; the classical side is responsible for filtering, inference, variance tests, confidence intervals, basis replacement checks, penalty updates, and generalized eigenvalue solves. This suggests that IQA performance is often governed as much by classical reduction quality and numerical stability as by the raw capability of the quantum subroutine.

6. Classical limits, nontrivial regimes, and current research directions

Several papers emphasize that an iterative quantum outer loop does not by itself imply a quantum advantage. For Maximum Independent Set, the depth-$10$2 Iterative QAOA selection rule has the exact form

$10$3

which depends only on vertex degree; the paper states that, for all tested instances, Iterative QAOA-1 made exactly the same selections as the corresponding greedy classical algorithm (Brady et al., 2023). In the quantum DPLL analysis, the small-$10$4, $10$5 branching rule reduces to a first-order clause-count heuristic, and a split-polarity construction is introduced precisely so that the quantum rule reproduces the Jeroslow–Wang literal-ranking structure more closely (Brady et al., 2 Sep 2025).

These classical limits are not presented as anomalies. They function as calibration points for identifying when deeper circuits, richer observables, or stronger inference begin to matter. For MIS, the reported empirical improvements appear only for $10$6 circuits and for variants such as MMQ; for quantum DPLL, the proposed regimes of improvement are tied to better-than-classical selection information, higher-depth QAOA, and constraint-rich instances where inference can prune the search tree more effectively (Brady et al., 2023, Brady et al., 2 Sep 2025).

The present literature is correspondingly cautious. IQuCS reports substantial qubit savings but no full theoretical performance bound (Mu et al., 2022). The generalized IQA and quantum DPLL analyses provide evidence for regimes of quantum improvement, but also note small-instance numerics and the cost of richer classical postprocessing (Brady et al., 2 Sep 2025). The QIPA separation critique argues that realistic exponential advantage over varQITE is not supported once approximation error is included (Czégel et al., 8 Feb 2025). The broader picture is therefore one of structured co-design: iterative quantum algorithms are most developed where the quantum device is used to generate actionable information, and the classical side converts that information into a demonstrably simpler, better-conditioned, or more hardware-compatible next problem instance.