---
title: 'Quantum Multigrid Algorithms: Methods & Performance'
url: https://www.emergentmind.com/topics/quantum-multigrid-algorithm
type: topic
---

# Quantum Multigrid Algorithms: Methods & Performance

Quantum multigrid algorithm denotes a family of quantum methods that transplant the core multigrid idea—coarse-to-fine hierarchy, information transfer across levels, and iterative error reduction—into quantum representations of states, operators, or circuits. In current arXiv usage, the term covers at least three distinct constructions: digitally encoded multigrid operating on an equal superposition of grid indices [2201.04513], block-encoded quantum multigrid for finite-element linear systems [2404.07466], and multigrid-inspired schemes for variational circuits and time-evolution-based many-body calculations [2312.15048], [2205.00094]. Related work on quantum iterative methods for differential equations and computational fluid dynamics makes the same connection explicit: instead of inverting large matrices, one can program quantum computers to perform multigrid-type computations through quantum smoothers, residual updates, and coarse-grid corrections [2404.08605].

## 1. Classical multigrid structure and its quantum translation

The common algorithmic backbone is the classical multigrid V-cycle. At a given level, the cycle applies pre-smoothing, computes the residual, restricts the residual to a coarser level, solves or smooths on the coarse grid, prolongates the correction back to the finer grid, and finishes with post-smoothing. In the finite-element formulation this is written for a hierarchy of grids with relaxation operator $R_L = I - \omega_L A_L$, residual $r_L = f_L - A_L v_L$, and level transfer operators satisfying the Galerkin identity $A_{L+1} = R_{L\to L+1} A_L P_{L+1\to L}$; repeated V-cycles drive the error $\|u-v_L\|$ down geometrically [2404.07466].

The digitally encoded construction preserves the same logical stages, but all operations act in parallel on an equal superposition of grid indices. For one V-cycle at level $i$, the quantum routine performs pre-smoothing $S^{s_0}$, residual computation, restriction $R$, recursive coarse solve, prolongation $P$, correction, and post-smoothing $S^{s_1}$; a W-cycle is obtained by using a branching factor $b>1$ in the recursive call [2201.04513].

The block-encoded finite-element qMG formalism translates the entire multigrid workflow into a product of unitaries. If $\{O_1,O_2,\dots,O_T\}$ are the block-encoded operations for pre-smoothing, residual computation, restriction, correction, and post-smoothing across all V-cycles and levels, the overall circuit is
$$
U_{\mathrm{qMG}} = O_T O_{T-1}\cdots O_1,
$$
and repeated use of block-encoding product lemmas shows that this unitary block-encodes the large linear map carrying the stacked iterate vector from input to output [2404.07466].

## 2. State encodings, block-encodings, and level-transfer operators

One major line of work uses a digital representation rather than amplitude-only storage. In that formulation, an approximate solution $\{u_i\}_{i=0}^{N-1}$ is stored on an $n$-qubit index register and a $k$-qubit data register as
$$
|u\rangle=\frac{1}{\sqrt{N}}\sum_{i=0}^{N-1}|i\rangle_n |u_i\rangle_k,
$$
where
$$
u_i=\sum_{b=0}^{k-1}2^{-b}u_i^{[b]},\qquad u_i^{[b]}\in\{0,1\},
$$
and
$$
|u_i\rangle=\bigotimes_{b=0}^{k-1}|u_i^{[b]}\rangle.
$$
A residual vector $r=(f-Au)$ is encoded in the same way, and the equal-amplitude superposition is maintained by only conditionally updating the data register given the index [2201.04513].

In that same framework, restriction and prolongation are implemented by quantum arithmetic conditioned on the least significant index bits because the underlying formulas only involve nearest neighbors. The reported depths are
$$
D_{\mathrm{restrict}} = O(\log N + k\log k),\qquad
D_{\mathrm{prolongate}} = O(\log N + k\log k),
$$
and nearest-neighbor information sharing is handled by a unitary $U_{\rm share}$ that maps $|i\rangle|u_i\rangle|0\rangle$ to $|i\rangle|u_i\rangle|u_{i\pm1}\rangle$ through controlled Grover-diffusion operators, 3-bit phase estimation, and uncomputation [2201.04513].

A second line of work uses block-encoding. A matrix $M$ with $\|M\|\le \alpha$ admits an $(\alpha,a)$-block-encoding $U_M$ when
$$
(\langle 0^a|\otimes I)\,U_M\,(|0^a\rangle\otimes I)=M/\alpha.
$$
This is the organizing primitive for quantum smoothing, restriction, and prolongation in the finite-element qMG algorithm, where the full multigrid evolution is embedded into a single amplitude-encoded state containing all intermediate blocks and repeated copies of the final block [2404.07466].

A third encoding strategy appears in the multigrid ansatz for variational quantum algorithms. There the hierarchy is over qubit count rather than mesh level: an ansatz on $j$ qubits is refined to $j+1$ qubits by appending one qubit in $|+\rangle$, adding $CZ$ entanglers between the new qubit and the old qubits, and inserting new $RY(\phi_k)$ rotations initialized to zero. The refinement satisfies
$$
U_{j+1}([\,\theta^*,0,\dots,0\,])\bigl(|0\rangle^{\otimes j}\otimes|0\rangle\bigr)
=
U_j(\theta^*)|0\rangle^{\otimes j}\otimes|+\rangle,
$$
which the paper identifies as a constant interpolation of the $j$-qubit state to $j+1$ qubits [2312.15048].

## 3. Algorithmic variants and application domains

For linear systems and PDE discretizations, the finite-element qMG algorithm is explicitly designed to address two issues associated with quantum linear system algorithms: growth of the condition number for finite-element problems and the inability of standard QLSAs to use an initial guess of a solution to improve upon it. The method applies the sequence of multigrid operations on a quantum state and produces a vector encoding the entire sequence of multigrid iterates, with the final iterate appearing as a subspace of the final quantum state [2404.07466].

The digitally encoded multigrid algorithm has a different emphasis. It keeps the index register in an equal superposition throughout the calculation and encodes numerical values digitally in the qubits in a way more similar to a classical computer than amplitude-based encodings. Its central technical problem is information sharing between neighboring grid points in superposition, which is needed for Jacobi- or Gauss-Seidel-type updates [2201.04513].

For differential equations and computational fluid dynamics, Williams et al. formulate the constituent quantum modules needed for a multigrid solver rather than presenting a full simulated V-cycle. Their construction maps classical multigrid components to quantum subroutines: Jacobi and Gauss-Seidel smoothers become block-encoded unitaries plus LCU updates, restriction and prolongation become block-encoded sparse-matrix oracles, and the coarse-grid correction is expressed through a Woodbury-identity resolvent decomposition. The paper also presents a Givens-rotation QR decomposition method for block-encoding that avoids oracles [2404.08605].

The multigrid ansatz for variational quantum algorithms moves the concept into the NISQ setting. Given a hierarchy of Hamiltonians $H_m\to H_{m+1}\to\cdots\to H_n$, the ansatz successively builds and optimizes circuits for smaller qubit counts and reuses optimized parameters as initial solutions at the next level. The paper positions this as a promising alternative to QAOA for combinatorial optimization problems and as a viable candidate for many VQAs, especially VQE [2312.15048].

A further extension appears in quantum subspace expansion for Green’s functions. There the “grid” is the time axis of Trotter evolution. The method constructs basis states by combining large coarse Trotter steps with a small number of fine steps, and the authors describe the resulting two-level scheme as the hallmark of a multigrid approach: coarse grid for global reach plus fine grid for local resolution [2205.00094].

## 4. Complexity claims and resource scaling

The strongest asymptotic claim in the digitally encoded formulation is conditional. With $q = n + k + O(\log N)$ qubits, one V-cycle has depth
$$
D_{\rm V}=O\bigl((s_0+s_1)+\log N+k\log k\bigr),
$$
and reducing the residual from $1$ to $\varepsilon$ requires $O(\log \varepsilon^{-1})$ V-cycles, yielding
$$
D_{\rm total}
=
O\Bigl(\bigl((s_0+s_1)+\log N + k\log k\bigr)\log\epsilon^{-1}\Bigr).
$$
The paper states that exponential speedup arises when the exact multigrid updates can be approximated by circuits of size $\mathrm{poly}(\log N)$ and the intermediate solutions remain compressible, so that the overall depth becomes $O(\mathrm{poly}(\log N)\log\epsilon^{-1})$ while classical multigrid costs $O(N\log\epsilon^{-1})$ [2201.04513].

For finite-element qMG, the informal statement of Theorem 7 gives runtime
$$
O\bigl((\sum_{i=1}^T \alpha_i)\,\mathrm{polylog}(N/\varepsilon)\bigr)
$$
and qubit count
$$
O\bigl((\sum \alpha_i)+\log N+\log T\bigr),
$$
with $T=O(V\cdot L\cdot v)=O(\mathrm{poly}\log N\cdot \log 1/\varepsilon)$. Amplitude amplification boosts the success probability from $p=O(1/\mathrm{polylog}\,N)$ to $O(1)$, leaving overall time complexity $O((\sum \alpha_i)\,\mathrm{polylog}(N/\varepsilon))$ and qubit count $O(\mathrm{polylog}(N/\varepsilon))$ [2404.07466].

The CFD-oriented iterative framework has a different scaling profile. The iteration count for classical Jacobi or Gauss-Seidel is reported as $K = O(\kappa)$ to reach fixed precision $\varepsilon$, and the quantum analog inherits the same scaling $K = O(\kappa)$. The paper reports width $n_fine = n + 2k + \lceil\log_2(k+1)\rceil$ qubits for naive multiplication of block-encodings across $k$ Jacobi steps, reducible with QSVT to $n + 4 + \lceil\log_2(k+1)\rceil$, and overall gate count $O(\kappa^2\cdot C(s,z)\cdot \log(1/\varepsilon))$ with total runtime $O(\kappa^2\cdot \mathrm{polylog}\,N)$ and memory $O(\log N)$ qubits [2404.08605].

The multigrid VQE ansatz has polynomial but not polylogarithmic scaling. If the seed size is $m$ and the refinement adds $N_{\rm ent}=j$ entanglers at level $j\to j+1$, the total parameter count is
$$
p_n = p_{\rm seed} + \sum_{j=m}^{n-1} j = O(n^2),
$$
the two-qubit gate count is $O(n^2)$, circuit depth is $D(n)=O(n^2)+O(\mathrm{poly}(n))=O(\mathrm{poly}(n))$, and the number of shots for $\varepsilon$-accuracy is $O(1/\varepsilon^2)$ [2312.15048].

In the two-level multigrid Trotter scheme for Green’s functions, the resource advantage is stated comparatively rather than asymptotically. A single-level Trotter approach in the Anderson-DMFT example requires approximately $80\ldots 100$ Trotter steps, corresponding to depth $\simeq 100\,d_V$, while the two-level multigrid construction keeps the effective circuit depth near $(\tilde n_l+1)d_V\lesssim 4\ldots 6\,d_V$ and yields an overall reduction in maximum 2-qubit gate depth by $\gtrsim 10\times$ [2205.00094].

## 5. Numerical performance and reported benchmarks

The multigrid VQE paper reports results on a discrete Dirichlet Laplacian eigensolver, MaxCut, and Max $k$-SAT. For the Laplacian eigensolver up to $12$ qubits, Efficient SU(2)-VQE “flattens quickly”: for $10^3$ shots the final energy error is $\gtrsim 10^{-1}$ and for $10^6$ shots it is $\gtrsim 10^{-2}$, whereas Multigrid-VQE continues improving and reaches $\sim 10^{-2}$ for $10^3$ shots and $\sim 10^{-3}$ for $10^6$ shots. The trade-off reported is that Multigrid uses approximately $2$–$3\times$ more optimizer calls while yielding $1$–$2$ orders of magnitude smaller error. On MaxCut with $15$ nodes and random $p\in\{0.3,0.6,0.9\}$, the average approximation ratio rises from about $0.75$–$0.85$ for Efficient SU(2)-VQE to about $0.85$–$0.92$ for Multigrid-VQE, and on Max 2-SAT and Max 3-SAT with $15$ variables the reported average ratio improves from about $0.70$–$0.80$ to about $0.80$–$0.88$, with lower variance for Multigrid [2312.15048].

The finite-element qMG work tests 1D Poisson with Dirichlet or Neumann boundary conditions up to $N\approx 16\,000$ unknowns and 2D Poisson on $[0,L]\times[0,L]$ with mixed boundary conditions up to $\sim 16\,000$ nodes, both with target relative error $\varepsilon=10^{-10}$. The reported qubit-overhead ratio $\log_2\mathrm{len}(x)/\log_2 N$ approaches $1.3$–$1.8$ for large $N$, the empirical success probability $p_{\mathrm{index}}$ of measuring the final block exceeds $0.9$ for moderate V and large $N$, and the multigrid error $\|v-u\|$ shrinks geometrically with the number of V-cycles [2404.07466].

Williams et al. benchmark the smoother-based quantum iterative modules on fluid-dynamics-motivated problems. For Burgers’ equation on an $N=128$ spatial by $M=150$ temporal grid, a Jacobi smoother alone with $k=30$ yields fidelity $>1-10^{-6}$ in $30$ iterations and the full surface is recovered after $K=80$. For 2D Euler acoustics on $N_x=N_y=128$, $M=60$, Jacobi with $k=12$ is reported to reach a visually converged pressure field, and experiments on a tridiagonal $256\times 256$ system with $\kappa\in[3,70]$ show iteration count $K\sim O(\kappa)$. The paper is explicit that no full V-cycle was simulated [2404.08605].

The Green’s-function application instantiates two-level multigrid Trotter evolution on a $16$-qubit Anderson impurity model obtained from the single-band Hubbard model on the Bethe lattice with infinite coordination. The Trotter step depth is given as $d_V=36$ CNOT-layers and the reference-state preparation depth as $d_0=19$. In the metallic regime $U=2$, the reported setting $\tilde n_l=1$, $\tilde n_k=9$ requires $6$ total Trotter steps and a maximum depth of approximately $254$ CNOT-layers to reach subpercent error in the density of states. In the Mott insulating regime $U=8$, even $4$ total steps with $\tilde n_l=0$, $\tilde n_k\ge 59$ are reported to suffice to resolve the Hubbard gap and upper and lower bands [2205.00094].

## 6. Conditions, limitations, and interpretive boundaries

Several recurrent claims in this literature are explicitly conditional. The digitally encoded multigrid algorithm states an exponential speedup only for classes of problems where the solution vector can be compressed efficiently and where a quantum compiler can reduce the quantum circuit depth efficiently; the existence of efficient approximations $\tilde U^{(j)}$ relies on compressibility through wavelet- or Fourier-type expansions and on compiler identification of shallow arithmetic decompositions of the structured unitaries [2201.04513].

The finite-element qMG formulation separates state preparation from data extraction. It states that qMG can efficiently produce a vector encoding the entire sequence of multigrid iterates, and that extracting the final iterate from the sequence is efficient, but also states that extracting the sequence of iterates from the final quantum state can be inefficient. The same work emphasizes that, unlike standard QLSA, qMG accepts any amplitude-encoded initial guess and uses multigrid convergence rather than a $\kappa$-dependent global inversion to reduce error [2404.07466].

The CFD-oriented work demonstrates constituent subroutines rather than an end-to-end multilevel solver. Its summary is explicit that “although no full V-cycle was simulated,” the tested smoothers, block-encodings, and LCU steps establish that the relevant building blocks can be executed with modest $n+O(\log \kappa)$ qubits and depth scaling $\sim \kappa^2$; a plausible implication is that the multigrid claim there is presently modular rather than fully integrated [2404.08605].

The variational multigrid ansatz is also careful about scope. It reports better approximation ratios than small-$p$ QAOA and states that, at comparable circuit depth, $QAOA_p$ with $p\le 5$ yields approximation ratios $10$–$15\%$ below Multigrid-VQE, but it also states that no formal proof of quantum advantage is given. The comparison is therefore empirical and restricted to the tested regimes [2312.15048].

The term “quantum multigrid” can therefore be misleading if treated as a single canonical algorithm. In the present literature it may refer to geometric grid hierarchies for linear systems, index-superposition schemes with digitally stored values, block-encoded finite-element V-cycles, qubit-count refinement in variational ansätze, or two-level time-step hierarchies in Green’s-function calculations. This suggests that the unifying feature is not a unique encoding or complexity theorem, but the use of hierarchical coarse-to-fine structure to improve trainability, reduce depth, or control iterative error on a quantum device [2205.00094].

Source: https://www.emergentmind.com/topics/quantum-multigrid-algorithm