Linear Combination of Unitaries via Classical Postprocessing

• The paper’s main contribution is demonstrating that classical post-processing can reduce quantum circuit depth by expressing nonunitary operations as weighted sums or integrals over unitaries.
• It details a methodology where quantum circuits estimate unitary components and classical numerical integration (Monte Carlo, quasi‐Monte Carlo, deterministic grids) aggregates the results with controlled error.
• The approach is applied in tasks like ground state filtering and Green's function estimation, showing potential for improving quantum simulations and machine learning.

A linear combination of unitaries via classical post-processing (LCU-CPP) refers to a suite of strategies for implementing general quantum operations—often non-unitary or otherwise nontrivial functions of operators—by expressing them as either explicit sums or integrals over unitary operators, with the measurement results for each term combined on a classical computer. The central motivation for LCU-CPP is to reduce quantum resource requirements—specifically depth and ancilla requirements—by offloading the complexity of the quantum superposition or weighted summation to post-processing, even if it comes at the cost of increased classical work. This paradigm has been systematically developed and benchmarked in a variety of algorithmic settings, including quantum simulation, quantum linear systems, variational algorithms, quantum machine learning, and physics-informed quantum computations. What follows is a structured exposition of its principles, methods, and applications, anchored to the technical literature.

1. The LCU-CPP Approach: Definitions and Framework

The core of LCU-CPP methods is representing a desired (generally nonunitary) operator $F(A)$ as a sum or continuous integral involving unitaries: $F(A) = \int_V f(t)\, G(A, t)\, dt,$ where $G(A, t)$ is proportional to a unitary operator for each $t$ in the domain $V$, and $f(t)$ is a (possibly signed) weight function. The quantum circuit implements $G(A, t)$ for discrete $t$ and employs a primitive such as the Hadamard test to measure expectation values $\Re[\text{Tr}(G(A, t)\rho)]$. The final result is generated by classically combining the measured outcomes according to the integral (or sum) weights.

The generic procedure is:

1. Express $F(A)$ as a (possibly weighted) sum or integral over unitaries: Either through Fourier, Chebyshev, or Taylor expansion, $F(A)$ is written as $F(A) \approx \sum_j \alpha_j U_j$ or $F(A) = \int f(t) G(A, t) dt$.
2. Quantum evaluation of unitary terms: For each $j$ or each grid point $t$, estimate $\langle\psi|U_j|\psi\rangle$ or $\langle\psi|G(A, t)|\psi\rangle$ via circuits tailored to the unitaries' structure (e.g., Hadamard test, SWAP test, block-encodings).
3. Classical post-processing: Aggregate the measured quantities with weighting factors $\alpha_j$ or $f(t)$ to recover an estimate of $\langle\psi|F(A)|\psi\rangle$.

This replaces the deep, coherent quantum circuits (e.g., block-encoded LCU methods with prepare-select-unprepare sandwiching) by shallow, parallel calls to quantum subroutines and a potentially intensive classical integration or summation step (Kawamata et al., 17 Sep 2025).

2. Numerical Integration Strategies: Monte Carlo, Quasi-Monte Carlo, and Deterministic Grids

The accuracy and efficiency of LCU-CPP depend heavily on the numerical method used to perform the classical integration:

• Naive Monte Carlo (MC): Randomly samples values of $t$ from $p(t)\propto |f(t)|$, driving an expected error scaling of $O(1/\sqrt{K})$, where $K$ is the number of integration points. The error combines the quantum shot noise (from a finite number $M$ of Hadamard test samples per $t$) and the statistical error of MC integration (Kawamata et al., 17 Sep 2025).
• Quasi-Monte Carlo (QMC): Employs low-discrepancy sequences (e.g., Halton or Sobol) to uniformly fill the space, achieving an asymptotic error $O((\log K)^d/K)$ for integration dimension $d$. QMC generally outperforms random MC in smooth, low-to-moderate dimension settings (Kawamata et al., 17 Sep 2025). In LCU-CPP tasks (e.g., Gaussian filters, Green's functions), QMC demonstrated lower total error for practical $M$ and $K$.
• Deterministic grids (e.g., trapezoid rule): Used when $f(t)$ and $G(A, t)$ are smooth and uniformly bounded, the error is $O(1/K^{2/d})$ but with worse scaling in high dimension $d$. The constant factor can be large when the integration region is big or $f(t)$ is highly oscillatory (Kawamata et al., 17 Sep 2025).

The practical regime is controlled by both the quantum sample size $M$ (shots per grid point) and the classical integration grid size $K$. LCU-CPP methods robustly separate quantum and classical errors, so the overall error is typically

$$\text{(Total error)} \sim O(1/\sqrt{MK}) + \text{(integration error)},$$

with QMC delivering the best tradeoff in all tested quantum applications (Kawamata et al., 17 Sep 2025).

3. Physical and Algorithmic Applications

Ground State Estimation via Gaussian Filtering:

A typical task is to project onto the ground state of a Hamiltonian by acting with a Gaussian filter,

$$e^{-\tau^2 H^2} = \int_{-\infty}^\infty \exp\left( -\frac{t^2}{4\tau^2} \right) e^{-i H t} \frac{dt}{2 \tau \sqrt{\pi}},$$

where each $e^{-i H t}$ is unitary and estimable by a Hadamard test. The sum of weighted measurements yields $\langle O \rangle$ projected onto the low-energy state (Kawamata et al., 17 Sep 2025).

Green's Function Estimation:

Linear response and correlation functions often require the action of $(E-H)^{-1}$ or similar nonunitary maps, which are recast as

$(E-H)^{-1} = \int_0^\infty e^{- (E-H) t} dt,$

representable as an integral over unitary evolution $e^{-i (E-H)t}$ using an appropriate kernel. All such maps can be realized via the LCU-CPP strategy, with quantum estimation of $e^{-i H t}$ and classical summation (Kawamata et al., 17 Sep 2025).

Other notable settings:

• Block-encoded functions (matrix inversion, Gibbs state preparation).
• Quantum machine learning nonunitary layers (e.g., projections, ResNets, pooling) (Heredge et al., 27 May 2024), where measurement results for separately applied unitaries are combined to effect nonunitary transformations robustly.

4. Quantum Resource and Error Scaling

LCU-CPP enables resource reductions in several ways:

• Quantum depth: Each $G(A, t)$ is implemented separately and in shallow circuits, avoiding the deep, entangled ancilla manipulations of coherent LCU block-encodings.
• Ancilla requirements: Only the ancilla for the quantum measurement primitive (e.g., one for the Hadamard test) is needed; there is no need to implement full "prepare-select-unprepare" circuits that would load all weights into quantum amplitudes.
• Classical post-processing: The cost is dominated by the number of samples $K$ and their integration; scaling is competitive with or preferable to block-encoding when $G(A, t)$ are themselves efficient to apply and $F(A)$ is not too sharply peaked.

The overall error is analyzed as a combination of the quantum shot noise and the numerical integration error. The latter dominates unless the number of shots per point $M$ is small. For practical values (e.g., $M = 10^2-10^3$), quasi-Monte Carlo integration achieves substantially lower total error than MC or grid-based approaches for most relevant dimensions (Kawamata et al., 17 Sep 2025).

5. Advantages, Limitations, and Future Directions

Advantages:

• Dramatic circuit depth reduction by moving combination and normalization entirely to the classical side.
• Flexibility in implementing a wide range of nonunitary or filtered operations without bespoke quantum routines for each application.
• Asymptotically superior integration convergence rates (with QMC), allowing high-precision estimation with moderate hardware budgets.

Limitations:

• A large number of quantum circuit executions may be needed for fine-grid (large $K$) or high-precision applications, unless each $G(A, t)$ admits additional computational shortcuts.
• Integration error can dominate at low $M$, especially in high dimensions, although the impact is often controlled in low-dimensional physical applications.
• For integrands that are not sufficiently smooth or for domains with intricate structure, error analysis must be redone and constant factors may increase.

Outlook:

• The adoption of advanced integration strategies (QMC and hybrids) is likely to become standard in LCU-CPP frameworks as quantum hardware matures, especially as classical-quantum co-design tools improve (Kawamata et al., 17 Sep 2025).
• Extending these ideas to higher-dimensional kernels, adaptive quadrature, and hybrid quantum-classical Bayesian inference is a plausible direction.
• Empirical benchmarks on real hardware for LCU-CPP with QMC are expected to be a decisive step in establishing routines for near- and mid-term quantum algorithms.

6. Summary Table: Integration Error Scaling in LCU-CPP

Classical Integration	Error per $K$ (nodes)	Notes
Monte Carlo	$O(1/\sqrt{K})$	Sampling error dominates if $K$ moderate
Quasi-Monte Carlo	$O((\log K)^d/K)$	Superior in practice for $d \leq 2$
Trapezoid Rule	$O(1/K^{2/d})$	May have large constants for large $V$

Practical implementations should select integration methods balancing quantum run budgets ($M$), classical compute, and the regularity of $f(t) G(A, t)$.

• Quasi-Monte Carlo Method for Linear Combination Unitaries via Classical Post-Processing (Kawamata et al., 17 Sep 2025)
• Non-Unitary Quantum Machine Learning (Heredge et al., 27 May 2024)