arxiv: 2604.25148 · v1 · submitted 2026-04-28 · 🪐 quant-ph · cs.MS

Recognition: unknown

Extending UNIQuE: Quantum Simulation Speedup for the HHL Algorithm

Reece Robertson , Ameya Bhave

Authors on Pith no claims yet

Pith reviewed 2026-05-07 16:58 UTC · model grok-4.3

classification 🪐 quant-ph cs.MS

keywords HHL algorithmquantum simulationclassical emulationlinear systemsUNIQuEquantum computingscaling

0 comments

The pith

A classical emulation of the HHL algorithm scales exponentially only with the number of qubits needed to represent the linear system.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper extends the Unconventional Noiseless Intermediate Quantum Emulator to classically simulate the quantum Harrow-Hassidim-Lloyd algorithm for sampling solutions to linear systems. This emulation scales exponentially with qubit count alone for the linear system. Standard state vector simulation of HHL scales exponentially with both system size and the magnitude of the largest scaled eigenvalue, creating a runtime gap that the new method exploits. The authors compare the emulator against the Intel Quantum Simulator and report faster runtimes for small linear systems.

Core claim

In an extension of the Unconventional Noiseless Intermediate Quantum Emulator, this work introduces a classical emulation of the quantum Harrow-Hassidim-Lloyd algorithm for sampling from the solution space of linear systems. The emulated HHL algorithm scales exponentially with the number of qubits required to represent the linear system, which is an advantage over the state vector simulation of the HHL algorithm, which scales exponentially as a function of both the size of the linear system and the magnitude of its largest (scaled) eigenvalue. We benchmark our emulator by comparing it with the Intel Quantum Simulator and demonstrate a runtime advantage for small linear systems.

What carries the argument

The extended Unconventional Noiseless Intermediate Quantum Emulator that classically reproduces HHL sampling behavior.

If this is right

The emulation permits testing of HHL on linear systems larger than those feasible with standard state-vector methods.
It yields measurable runtime gains over the Intel Quantum Simulator for small linear systems.
Simulation cost grows only with qubit number rather than also with eigenvalue magnitude.
Classical verification of HHL outputs becomes practical for more cases without quantum hardware.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

Similar emulation strategies might extend to other quantum linear-algebra primitives that rely on phase estimation.
The approach could reduce iteration time when prototyping hybrid quantum-classical solvers for sparse systems.
If the fidelity holds at scale, it offers a way to stress-test HHL variants before they run on actual devices.

Load-bearing premise

The classical UNIQuE-based emulation accurately reproduces the sampling behavior and output distribution of the true quantum HHL algorithm without hidden costs or approximations that would remove the claimed scaling advantage.

What would settle it

Compare output distributions and runtimes of the emulated HHL against a true quantum implementation or full state-vector simulator on a linear system whose largest eigenvalue is large; any mismatch in scaling or fidelity would refute the advantage.

Figures

Figures reproduced from arXiv: 2604.25148 by Ameya Bhave, Reece Robertson.

**Figure 1.** Figure 1: A high-level overview of the HHL algorithm. The algorithm uses three quantum registers: a one-qubit view at source ↗

**Figure 2.** Figure 2: Illustrative results of simulating and emulating the HHL algorithm on ( view at source ↗

**Figure 3.** Figure 3: Illustrative results of simulating and emulating the HHL algorithm on ( view at source ↗

read the original abstract

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

The paper applies UNIQuE to emulate HHL and claims better scaling than state vector sims for small linear systems, but the advantage may hinge on untested eigenvalue dependencies.

read the letter

The main takeaway is that this work takes the existing UNIQuE classical quantum emulator and applies it to simulate the HHL algorithm, reporting that the emulation scales exponentially only with the qubit number for the linear system size. This contrasts with full state-vector simulation of HHL, which they say also scales with the largest eigenvalue. They demonstrate a runtime benefit over the Intel Quantum Simulator on small instances. What stands out positively is the direct benchmark comparison and the practical focus. Extending a known emulator to this algorithm and showing concrete speedups for small problems is a useful step for anyone needing to run HHL-like computations classically without full quantum resources. On the downside, the scaling claim could be sensitive to how the emulator handles the Hamiltonian simulation and phase estimation inside HHL. If there are costs proportional to the eigenvalue magnitude that only appear at larger scales, the advantage might not persist beyond the tested cases. The abstract and available details do not include a full error analysis or implementation breakdown, so that remains a point to verify. This paper targets researchers in quantum computing who want efficient classical tools for testing linear system solvers on modest sizes, such as in quantum machine learning prototypes. It is not a major theoretical advance but provides a targeted improvement. I recommend putting it through peer review. The work is grounded enough in its claims and benchmarks to merit referee feedback on the methods and scaling behavior.

Referee Report

2 major / 1 minor

Summary. The paper extends the Unconventional Noiseless Intermediate Quantum Emulator (UNIQuE) to classically emulate the Harrow-Hassidim-Lloyd (HHL) algorithm for sampling solutions to linear systems. It claims that the emulated HHL scales exponentially only with the number of qubits n = log N needed to represent the system, providing an advantage over state-vector simulation of HHL, which scales exponentially with both system size and the magnitude of the largest (scaled) eigenvalue λ_max. A runtime benchmark against the Intel Quantum Simulator is presented for small linear systems.

Significance. If the UNIQuE-based emulation correctly reproduces HHL sampling distributions without incurring hidden costs proportional to λ_max or the condition number, the work would supply a concrete classical tool for benchmarking small-scale quantum linear-system solvers and could help clarify practical simulation costs. The explicit benchmark comparison is a strength, but the absence of any derivation, cost analysis, or scaling proof limits the result to an empirical observation on small instances.

major comments (2)

[Abstract, §1] Abstract and §1 (introduction): The central scaling claim—that the emulation depends only on n = log N and avoids factors from λ_max—is stated without any derivation, complexity analysis, or accounting of the Hamiltonian simulation and phase-estimation steps inside UNIQuE. Standard HHL costs are known to depend on λ_max; the manuscript must show explicitly why the emulator evades this dependence.
[Benchmark section] Benchmark section (presumably §4 or §5): The comparison with the Intel Quantum Simulator is restricted to small linear systems. This does not address whether UNIQuE emulation incurs eigenvalue-dependent overheads that would appear only at larger N or larger λ_max, undermining the claimed asymptotic advantage.

minor comments (1)

[Abstract] The abstract and introduction should include a brief statement of the matrix ensemble, condition numbers, and eigenvalue ranges used in the benchmarks so that the scaling comparison can be reproduced.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the constructive feedback and for recognizing the benchmark comparison as a strength. The comments highlight the need for explicit analysis to support the scaling claims. We will revise the manuscript accordingly to address these points while maintaining the focus on small-system demonstrations.

read point-by-point responses

Referee: [Abstract, §1] Abstract and §1 (introduction): The central scaling claim—that the emulation depends only on n = log N and avoids factors from λ_max—is stated without any derivation, complexity analysis, or accounting of the Hamiltonian simulation and phase-estimation steps inside UNIQuE. Standard HHL costs are known to depend on λ_max; the manuscript must show explicitly why the emulator evades this dependence.

Authors: We agree that the current manuscript states the scaling without a dedicated derivation. The UNIQuE extension emulates the circuit by operating on a compact representation whose cost grows with n and the number of gates, rather than materializing the full state vector; the HHL components (Hamiltonian simulation via Trotterization or similar, and phase estimation) are emulated gate-by-gate with the same representation, so the classical runtime inherits only the gate count of the circuit rather than an extra multiplicative factor from λ_max beyond what is already required for the desired precision. In the revision we will add a new subsection deriving the emulation complexity, explicitly contrasting it with state-vector simulation (which multiplies the 2^n memory cost by the full circuit depth, including λ_max-dependent steps for phase estimation). revision: yes
Referee: [Benchmark section] Benchmark section (presumably §4 or §5): The comparison with the Intel Quantum Simulator is restricted to small linear systems. This does not address whether UNIQuE emulation incurs eigenvalue-dependent overheads that would appear only at larger N or larger λ_max, undermining the claimed asymptotic advantage.

Authors: The abstract and results section explicitly limit the runtime-advantage claim to small linear systems, where the benchmarks demonstrate a clear practical benefit. We acknowledge that the empirical data alone cannot rule out hidden λ_max-dependent costs that might emerge at larger scales. In the revision we will expand the benchmark discussion to include (i) a short theoretical argument that the emulation cost remains polynomial in the circuit depth (hence in any fixed-precision λ_max factor) and exponential only in n, and (ii) additional small-system runs that vary λ_max while keeping n fixed, to empirically check for such overheads within the accessible regime. revision: partial

Circularity Check

0 steps flagged

No significant circularity; scaling claim rests on external benchmark comparison rather than self-referential definition or fitted inputs

full rationale

The paper's central claim is that the UNIQuE-based classical emulation of HHL scales exponentially only in the number of qubits n = log N, providing an advantage over state-vector simulation that scales in both N and λ_max. This is supported by direct runtime benchmarks against the Intel Quantum Simulator on small linear systems, without any derivation step that reduces the claimed scaling to a fitted parameter, a self-citation chain, or an ansatz imported from the authors' prior work. The emulation is presented as reproducing the quantum algorithm's sampling behavior, and the advantage is asserted via explicit comparison rather than by construction. No load-bearing step equates the output distribution or scaling to the input assumptions in a circular manner.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

Based solely on the abstract, no explicit free parameters, axioms, or invented entities are stated. The emulation presumably rests on standard assumptions of quantum circuit simulation and classical emulation techniques that are not detailed here.

pith-pipeline@v0.9.0 · 5394 in / 1264 out tokens · 51422 ms · 2026-05-07T16:58:48.424280+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

23 extracted references · 14 canonical work pages · 1 internal anchor

[1]

Dalzell et al.Quantum Algorithms: A Survey of Applications and End-to-end Complexities

Alexander M. Dalzell et al.Quantum Algorithms: A Survey of Applications and End-to-end Complexities. Cambridge University Press, 2025

2025
[2]

Quantum Algorithm for Linear Systems of Equations

Aram W. Harrow, Avinatan Hassidim, and Seth Lloyd. “Quantum Algorithm for Linear Systems of Equations”. In:Phys. Rev. Lett.103.15 (Oct. 2009). Publisher: American Physical Society, p. 150502.DOI: 10.1103/ PhysRevLett.103.150502.URL: https://link.aps.org/ doi / 10 . 1103 / PhysRevLett . 103 . 150502 (visited on 09/26/2023)

2009
[3]

Quantum computing with realistically noisy devices,

E. Knill. “Quantum computing with realistically noisy devices”. In:Nature434.7029 (Mar. 2005), pp. 39–44. ISSN: 1476-4687.DOI: 10 . 1038 / nature03350.URL: https://doi.org/10.1038/nature03350

work page doi:10.1038/nature03350 2005
[4]

Benchmark- ing Quantum Computers and the Impact of Quantum Noise

Salonik Resch and Ulya R. Karpuzcu. “Benchmark- ing Quantum Computers and the Impact of Quantum Noise”. In:ACM Comput. Surv.54.7 (July 2021).ISSN: 0360-0300.DOI: 10.1145/3464420.URL: https://doi. org/10.1145/3464420

work page doi:10.1145/3464420.url: 2021
[5]

Simon’s Algorithm in the NISQ Cloud

Reece Robertson et al. “Simon’s Algorithm in the NISQ Cloud”. In:Entropy27.7 (2025).ISSN: 1099-4300.DOI: 10.3390/e27070658.URL: https://www.mdpi.com/1099- 4300/27/7/658

work page doi:10.3390/e27070658.url: 2025
[6]

Implementing Grover’s Algo- rithm on NISQ Chips

Reece Robertson et al. “Implementing Grover’s Algo- rithm on NISQ Chips”. In:NAECON 2025 - IEEE Nat. Aerospace and Electronics Conf.2025, pp. 1–6.DOI: 10.1109/NAECON65708.2025.11235338

work page doi:10.1109/naecon65708.2025.11235338 2025
[7]

On the Baltimore Light RailLink into the quantum future

Krzysztof Domino et al. “On the Baltimore Light RailLink into the quantum future”. In:Sci. Rep.15.1 (Aug. 2025), p. 29576.ISSN: 2045-2322.DOI: 10.1038/ s41598- 025- 15545- 0.URL: https://doi.org/10.1038/ s41598-025-15545-0

2025
[8]

Reece Robertson et al.V ariational Gibbs State Prepara- tion on Trapped-Ion Devices. 2026. arXiv: 2603.03801 [quant-ph].URL: https://arxiv.org/abs/2603.03801

work page arXiv 2026
[9]

Cambridge university press, 2013

Daniel A Lidar and Todd A Brun.Quantum error correction. Cambridge university press, 2013

2013
[10]

Quantum error correction below the surface code threshold

Rajeev Acharya et al. “Quantum error correction below the surface code threshold”. In:Nature638.8052 (Feb. 2025), pp. 920–926.ISSN: 1476-4687.DOI: 10.1038/ s41586- 024- 08449- y.URL: https://doi.org/10.1038/ s41586-024-08449-y

2025
[11]

Colburn Riffel, Reece Robertson, and Peter Hendrick- son.Fault-Tolerant Error Detection Above Break-Even for Multi-Qubit Gates. 2026. arXiv: 2604 . 13219 [quant-ph].URL: https://arxiv.org/abs/2604.13219

work page internal anchor Pith review Pith/arXiv arXiv 2026
[12]

Implementing Grover’s Algo- rithm on NISQ Chips

Colburn Riffel et al. “Steane and Iceberg Code Imple- mentations on Toffoli Gates”. In:NAECON 2025 - IEEE Nat. Aerospace and Electronics Conf.2025, pp. 1–6. DOI: 10.1109/NAECON65708.2025.11235387

work page doi:10.1109/naecon65708.2025.11235387 2025
[13]

Elementary gates for quantum computation

Adriano Barenco et al. “Elementary gates for quantum computation”. In:Phys. Rev. A52 (5 Nov. 1995), pp. 3457–3467.DOI: 10.1103/PhysRevA.52.3457.URL: https://link.aps.org/doi/10.1103/PhysRevA.52.3457

work page doi:10.1103/physreva.52.3457.url: 1995
[14]

Nielsen and Isaac L

Michael A. Nielsen and Isaac L. Chuang.Quantum Computation and Quantum Information: 10th Anniver- sary Edition. en. ISBN: 9780511976667 Publisher: Cambridge University Press. Dec. 2010.DOI: 10.1017/ CBO9780511976667

2010
[15]

Quantum simulation of reaction dynamics by density matrix evo- lution

Herman JC Berendsen and Janez Mavri. “Quantum simulation of reaction dynamics by density matrix evo- lution”. In:J. Phys. Chem.97.51 (1993), pp. 13464– 13468

1993
[16]

Tensor networks for complex quantum systems

Rom ´an Or ´us. “Tensor networks for complex quantum systems”. In:Nat. Rev. Phys.1.9 (Sept. 2019), pp. 538– 550.ISSN: 2522-5820.DOI: 10.1038/s42254-019-0086- 7.URL: https://doi.org/10.1038/s42254-019-0086-7

work page doi:10.1038/s42254-019-0086- 2019
[17]

Introducing UNIQuE: The Unconventional Noiseless Intermedi- ate Quantum Emulator

Reece Robertson and Dan Ventura. “Introducing UNIQuE: The Unconventional Noiseless Intermedi- ate Quantum Emulator”. In:2025 IEEE Int. Conf. on Collaborative Advances in Software and COmput- iNg (CASCON). 2025, pp. 545–554.DOI: 10 . 1109 / CASCON66301.2025.00086

work page arXiv 2025
[18]

David Mermin.Quantum Computer Science: An Introduction

N. David Mermin.Quantum Computer Science: An Introduction. Cambridge University Press, 2007

2007
[19]

Automatically tuned linear algebra software,

Thomas H ¨aner et al. “High Performance Emulation of Quantum Circuits”. In:SC ’16: Proc. of the Int. Conf. for High Performance Computing, Networking, Storage and Analysis. 2016, pp. 866–874.DOI: 10.1109/SC. 2016.73

work page doi:10.1109/sc 2016
[20]

Hector Jose Morrell Jr au2, Anika Zaman, and Hiu Yung Wong.Step-by-Step HHL Algorithm Walkthrough to En- hance the Understanding of Critical Quantum Comput- ing Concepts. 2023. arXiv: 2108.09004[quant-ph]

work page arXiv 2023
[21]

Jonathan Richard Shewchuk et al.An introduction to the conjugate gradient method without the agonizing pain. 1994

1994
[22]

Max Planck: the reluctant revolutionary

Gian Giacomo Guerreschi et al. “Intel Quantum Sim- ulator: a cloud-ready high-performance simulator of quantum circuits”. In:Quantum Sci. Technol.5.3 (May 2020), p. 034007.DOI: 10.1088/2058- 9565/ab8505. URL: https://dx.doi.org/10.1088/2058-9565/ab8505

work page doi:10.1088/2058- 2020
[23]

Mikhail Smelyanskiy, Nicolas P. D. Sawaya, and Al ´an Aspuru-Guzik.qHiPSTER: The Quantum High Per- formance Software Testing Environment. 2016. arXiv: 1601.07195[quant-ph].URL: https://arxiv.org/abs/ 1601.07195

work page arXiv 2016