---
title: Quantum Orthogonal Matching Pursuit (QOMP)
url: https://www.emergentmind.com/topics/quantum-orthogonal-matching-pursuit-qomp
type: topic
---

# Quantum Orthogonal Matching Pursuit (QOMP)

Quantum Orthogonal Matching Pursuit (QOMP) is a quantum sparse-recovery algorithm for non-orthogonal, overcomplete dictionaries, introduced as the first quantum analogue of the classical OMP greedy algorithm. In the formulation of "Quantum Sparse Recovery and Quantum Orthogonal Matching Pursuit" [2510.06925], the task is to reconstruct a pure quantum state from coherent quantum access to the state and to a dictionary of vectors, up to $\ell_2$ error, using as few dictionary elements as possible. QOMP combines quantum inner-product estimation, quantum maximum finding, and block-encoded projections, and its central design feature is an error-resetting mechanism that recomputes the residual from the target state and the current support rather than updating it incrementally. Under mutual incoherence and well-conditioned sparsity assumptions, it provably recovers the exact support of a $K$-sparse state in polynomial time, while the underlying general recovery problem remains NP-hard in full generality [2510.06925].

## 1. Problem formulation and oracle model

QOMP is defined for sparse recovery in a possibly overcomplete dictionary $\Phi = [\phi_1,\ldots,\phi_m] \in \mathbb{C}^{N\times m}$ with unit-norm columns $\phi_j \in \mathbb{C}^N$. A coefficient vector $x \in \mathbb{C}^m$ is $K$-sparse if $|S|=K$ for $S=\operatorname{supp}(x)\subseteq[m]$. The target is a pure quantum state $|\psi\rangle \in \mathbb{C}^N$ that admits a sparse representation $|\psi\rangle \approx \Phi x$. The approximate sparse-recovery objective is
\[
\min \|x\|_0 \quad \text{subject to} \quad \bigl\|\,|\psi\rangle-\Phi x\,\bigr\|_2 \le \epsilon,
\]
while exact recovery replaces the constraint by equality.

Two structural quantities govern the guarantees. The mutual incoherence is
\[
\mu(\Phi):=\max_{i\neq j} |\langle \phi_i,\phi_j\rangle|,
\]
and for a support $S$, the subdictionary condition number is
\[
\kappa(\Phi_S):=\frac{\sigma_{\max}(\Phi_S)}{\sigma_{\min}(\Phi_S)}.
\]
The analysis also uses a known lower bound $\gamma \le \sigma_{\min}(\Phi_S)$.

The access model assumes oracular circuits
\[
U_s: |0\rangle \mapsto |\psi\rangle,\qquad
U_D: |j\rangle|0\rangle \mapsto |j\rangle|\phi_j\rangle,
\]
together with inverses and controlled versions. In the QRAM model, coherent queries to the dictionary in superposition enable efficient block-encodings. Given quantum access to a matrix $A$ such as $\Phi$ or $\Phi_S$, one obtains a block-encoding $U_A$ of $A$ with normalization $\alpha \in \{\|A\|_F,\mu_p(A)\}$, and QSVT can then implement matrix functions including pseudoinverses and spectral projectors [2510.06925].

The problem setting is deliberately non-orthogonal. That distinction is not cosmetic: the recovery objective, the support conditions, the tomography application, and the complexity separation from dense orthonormal-state tomography all depend on sparsity in a non-orthogonal dictionary rather than on sparsity in an orthonormal basis.

## 2. Core algorithmic mechanism

QOMP operates directly on $|\psi\rangle$ and the dictionary oracles. Its iterative state is a support set $S_t$, an orthogonal projection onto the span of the selected atoms, and a residual defined from that projection. For a support $S_t$ after $t$ selections, the projector is
\[
P_{S_t}:=\Phi_{S_t}\bigl(\Phi_{S_t}^\dagger \Phi_{S_t}\bigr)^{-1}\Phi_{S_t}^\dagger,
\]
and the residual is
\[
r_t := (I-P_{S_t})|\psi\rangle.
\]

A defining feature is that QOMP does not necessarily prepare $|r_t\rangle$ as a state. Instead, it computes correlations through
\[
\langle \phi_j,r_t\rangle = \langle \phi_j,\psi\rangle - \langle \phi_j,\phi_t\rangle,
\]
where $|\phi_t\rangle := P_{S_t}|\psi\rangle$ is implemented using a block-encoded projection. This is the error-resetting design: after each support update, the algorithm recomputes the projected component from the original state and the current support, rather than propagating an approximate residual from earlier iterations [2510.06925].

The selection step combines approximate inner-product estimation with quantum maximum finding. For each $j\notin S_t$, QOMP estimates
\[
c_j \approx \langle \phi_j,r_t\rangle.
\]
The real and imaginary parts are obtained by amplitude-estimation-based routines. From these estimates, one implements an oracle
\[
O_i: |j\rangle|0\rangle \mapsto |j\rangle|z_j\rangle
\]
such that
\[
|z_j-|\langle \phi_j,r_t\rangle|| \le \epsilon_i.
\]
Dürr-Høyer maximum finding is then applied over $j\notin S_t$ to choose an index approximating the maximizer of $|\langle \phi_j,r_t\rangle|$.

After selection, the support is updated by $S_{t+1}=S_t\cup\{j_t\}$, and the algorithm recomputes
\[
|\phi_{t+1}\rangle = P_{S_{t+1}}|\psi\rangle = \Phi_{S_{t+1}}\Phi_{S_{t+1}}^+|\psi\rangle
\]
via block-encodings and QSVT. The construction proceeds through a block-encoding of the projector onto the column space of $\Phi_S$, using singular-value techniques and polynomial approximations of sign.

The stopping rule is based on residual-norm estimation. QOMP estimates $\|r_t\|_2$ by a weighted Euclidean distance routine with additive error $\epsilon_f$, and it stops when the estimated residual norm is at most $\epsilon$ (or a preset $\epsilon/2$ in the exact statement of the main recovery theorem) or after $K$ iterations. Once the support has been identified, coefficients are obtained by solving least squares on $\Phi_{S_T}$ using a block-encoded linear-system routine to prepare a state proportional to $\Phi_{S_T}^+|\psi\rangle$, followed by orthogonal sparse tomography in an orthonormal basis to output a sparse classical vector [2510.06925].

## 3. Recovery guarantees and complexity bounds

The main support-recovery guarantee is a quantum exact recovery condition with slack. If $\eta\in(0,1)$ bounds the tolerance of approximate inner products, QOMP selects the correct atom at each iteration provided
\[
\max_{\phi \in \operatorname{columns}(\Phi_{\overline{\Lambda_{\mathrm{opt}}}})}
\|\Phi_{\Lambda_{\mathrm{opt}}}^+ \phi\|_1 < 1-\eta,
\]
and the inner-product accuracy satisfies
\[
\epsilon_i \le \frac{\eta}{2}\min_{t\le K}\|\Phi_{\Lambda_{\mathrm{opt}}}^\dagger r_t\|_\infty.
\]
This is explicitly presented as a quantum extension of the classical ERC with slack $\eta$ [2510.06925].

A more explicit sufficient condition is given in terms of mutual incoherence. QOMP selects a correct atom at every iteration if
\[
K < \frac{1-\eta}{2-\eta}\bigl(\mu(\Phi)^{-1}+1\bigr),
\]
with the same accuracy condition on $\epsilon_i$. In the limit $\eta \to 0$, this recovers the classical OMP condition $K < (\mu^{-1}+1)/2$.

The per-iteration expected cost in the oracular-circuit model is
\[
O\!\left(
\sqrt{m}\,T_{\overline{\Lambda}}
+
\|\psi\|^2\!\left(
\frac{\sqrt{m}}{\epsilon_i}+\frac{1}{\epsilon_f}
\right)
\left(
T_s+\frac{(T_D+T_\Lambda)\sqrt{k}}{\gamma}
\right)
\right),
\]
plus classical time $T_U$ to update the support. The dependence on $\gamma$ reflects the conditioning of the selected subdictionary, and the analysis emphasizes that errors do not accumulate across iterations because the residual is always recomputed as a projection.

For sparse recovery to target error $\epsilon$, if
\[
K < \frac{1-\eta}{2-\eta}\bigl(\mu^{-1}+1\bigr),\qquad
\epsilon_i \le \eta\gamma\epsilon/\sqrt{K},\qquad
\epsilon_f=\epsilon/2,
\]
then running QOMP for at most $K$ iterations or until residual at most $\epsilon/2$ yields the overall query bounds
\[
\widetilde{O}\!\left(\frac{K^{3/2}}{\gamma\eta}\cdot\frac{\sqrt{m}}{\epsilon}\right)
\quad \text{queries to } U_s,U_s^\dagger,
\]
and
\[
\widetilde{O}\!\left(\frac{K^2}{\gamma\eta}\cdot\frac{\sqrt{m}}{\epsilon}\right)
\quad \text{queries to } U_D,U_D^\dagger,
\]
plus polynomially many additional resources. Success probability can be amplified to at least $1-\delta$ with an $O(\log(1/\delta))$ overhead.

Support recovery can be strengthened to an identifiability statement: if no support smaller than $|\Lambda_{\mathrm{opt}}|$ yields an $\epsilon$-approximation, then QOMP recovers $\Lambda_{\mathrm{opt}}$ with high probability. After support recovery with residual $\epsilon/4$, one can output a classical vector $y$ with sparsity $O(K\log K\log(1/\delta))$ such that
\[
\left\|\,|\psi\rangle - \frac{\Phi_S y}{\|\Phi_S y\|}\right\| \le \epsilon
\]
using
\[
O\!\left(\frac{K^2}{\gamma^2\epsilon}\operatorname{polylog}(1/\delta)\right)
\]
queries. In the regime $K=\widetilde{O}(1)$, this coefficient-extraction stage is typically dominated by support recovery [2510.06925].

## 4. Hardness, scope, and structural assumptions

The general quantum sparse-recovery problem is NP-hard. For any $\epsilon < \sqrt{3/N}$, the exact and approximate formulations $QP0$ and $QP0^\epsilon$ are NP-hard via a reduction from Exact Cover by 3-Sets. In that reduction, each 3-set is encoded as a dictionary state uniform over its three elements, and the target is the uniform superposition over the ground set; an exact cover exists if and only if there is a sparse combination of $N/3$ such dictionary states that approximates the target to error below $\sqrt{3/N}$. The stated implication is that, unless $\mathrm{NP}\subseteq\mathrm{BQP}$, no quantum algorithm can solve $QP0^\epsilon$ in $\operatorname{poly}(N)$ queries and gates in the worst case [2510.06925].

This hardness result clarifies the role of QOMP’s assumptions. The algorithm is not a worst-case solver for arbitrary non-orthogonal sparse-recovery instances. Its guarantees are conditional on incoherence, on favorable conditioning of the active subdictionary, and on sufficiently accurate approximate subroutines. The paper’s complexity bounds therefore belong to the structured regime in which the support obeys both an ERC-like separation condition and a lower singular-value bound.

The same point resolves a frequent misunderstanding about the tomography application. The paper states that QOMP can circumvent the $\widetilde{\Omega}(N/\epsilon)$ lower bound that holds in the dense, orthonormal-dictionary setting, but without contradiction, because the relevant regime assumes sparsity together with non-orthogonality. The lower bound applies to dense arbitrary pure states in orthonormal bases without sparsity promises; QOMP’s setting is different in both respects [2510.06925].

## 5. Sparse tomography, QRAM acceleration, and incoherence estimation

QOMP yields the first framework for sparse quantum tomography with non-orthogonal dictionaries in $\ell_2$ norm. The decomposition is explicit: support recovery is performed first, and coefficient estimation is then restricted to the recovered support. In place of learning $N$ amplitudes, the procedure estimates only $K$ coefficients, assuming the relevant subdictionary is well conditioned. In favorable regimes it achieves query complexity $\widetilde{O}(\sqrt{N}/\epsilon)$, and for pure-state tomography with $m=O(N)$ dictionary vectors and sparsity $K=\widetilde{O}(1)$ on a well-conditioned subdictionary, support recovery uses $\widetilde{O}(\sqrt{N}/\epsilon)$ queries to $U_s$, with coefficients adding $\widetilde{O}(1/\epsilon)$ [2510.06925].

In the QRAM model, the data-access assumptions become stronger and the complexity improves further. With QRAM, block-encodings can use normalization $\alpha=\mu_p(\Phi_S)\le \|\Phi_S\|_F=\sqrt{k}$ rather than $\|\Phi_S\|_F$, and the per-iteration expected time becomes
\[
O\!\left(
\|\psi\|^2\cdot \frac{\mu(\Phi_S)}{\gamma}\cdot
\left(\frac{\sqrt{m}}{\epsilon_i}+\frac{1}{\epsilon_f}\right)
\right).
\]
The paper states that this yields polynomial speedups over classical OMP variants, with QOMP achieving sublinear $\sqrt{m}$ dependence per iteration in QRAM. The same section specifies the memory model: QRAM stores $\Phi$ in KP-trees with $O(\operatorname{nnz}(\Phi)\operatorname{polylog}(Nm))$ memory, supports dynamic updates of $\Lambda$ and its complement in polylogarithmic time, and has memory footprint $O(Nm\log(Nm))$ cells [2510.06925].

The framework also includes a quantum estimator for mutual incoherence. Given QRAM or oracular access to the unit-norm columns of $\Phi$, the algorithm estimates
\[
\mu(\Phi)=\max_{i\neq j} |\langle \phi_i,\phi_j\rangle|
\]
to additive error $\epsilon$ with high probability in time $O(T_D\cdot m/\epsilon)$. The procedure prepares a superposition over pairs $(i,j)$ with $i\neq j$, coherently evaluates pairwise inner products, and applies Dürr-Høyer maximum finding. The claimed improvement is quadratic in $m$ relative to deterministic classical $O(m^2n)$ and quantum-inspired classical $O(m^2/\epsilon^2)$ methods [2510.06925].

These applications are significant because they extend sparse-recovery methodology from a purely algorithmic setting to concrete quantum data-analysis tasks. A plausible implication is that the usefulness of QOMP is largest when three conditions coincide: small effective sparsity, an overcomplete but incoherent dictionary, and access models that make coherent dictionary queries realistic.

## 6. Relation to classical OMP and earlier quantum matching pursuit

QOMP inherits the projection-based logic of classical OMP: selection is driven by maximal correlation with the current residual, while the residual itself is defined by orthogonal projection onto the span of the selected atoms. The recovery conditions in terms of mutual incoherence and ERC are stated as direct quantum counterparts of classical OMP guarantees, modified by an $\eta$-slack that accounts for approximate quantum subroutines [2510.06925].

Its closest prior quantum relative is Quantum Matching Pursuit (QMP), which proposed a quantum version of classical matching pursuit under a fault-tolerant QRAM assumption [2208.04145]. QMP uses quantum inner-product estimation and Dürr-Høyer maximum finding to lower the complexity of sparse-representation search by a polynomial factor, and the paper reports numerical experiments in which the estimation error is negligible in practice. However, QMP is a quantum analogue of matching pursuit rather than orthogonal matching pursuit: its workflow is organized around residual access in QRAM and single-atom updates, whereas QOMP recomputes projection-based residual information at each iteration through block-encodings and QSVT [2208.04145].

This distinction is methodologically central. The QOMP paper explicitly notes that QMP requires QRAM access to the residual, which is unsuitable for pure tomography with only $U_s$ access, while QOMP avoids storing residuals by recomputing projections from the target state and the selected support. In that sense, QOMP is not merely a faster sweep over dictionary atoms; it is a different quantum realization of greedy sparse recovery, tailored to the setting in which the data are available as a quantum state rather than as a classically stored vector.

The limitations follow directly from the same design. QOMP requires coherent state-preparation unitaries, dynamic support-access routines, block-encodings with known normalization, a lower bound on $\sigma_{\min}(\Phi_S)$, amplitude-estimation variants for inner products, maximum finding, and QSVT. Its guarantees deteriorate when supports are poorly conditioned, since small $\gamma$ increases the query complexity, and atom selection requires $\epsilon_i$ to be small relative to $\|\Phi_S^\dagger r\|_\infty$. The largest savings therefore occur in the regime explicitly isolated in the paper: small $K$, favorable conditioning, and sufficiently incoherent non-orthogonal dictionaries [2510.06925].

Source: https://www.emergentmind.com/topics/quantum-orthogonal-matching-pursuit-qomp