Solving Systems of Linear Equations: HHL from a Tensor Networks Perspective
Pith reviewed 2026-05-06 19:34 UTC · model claude-opus-4-7
The pith
A tensor-network simulator reproduces HHL output by recasting it in qudits and swapping unitary steps for non-unitary contractions, giving a noise-free performance ceiling.
A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.
Core claim
The paper rewrites the HHL quantum linear-systems algorithm in qudit form and then replaces each step with a tensor-network contraction that is allowed to be non-unitary. Because a classical simulator is not bound by reversibility, steps that are expensive to enact unitarily on hardware (notably the eigenvalue-inversion conditional rotation and the post-selection) collapse into direct contractions. The authors argue this gives a faithful, noise-free simulation of HHL's output that scales better than gate-level simulation, and they use it to chart how HHL accuracy depends on its hyperparameters.
What carries the argument
A tensor-network rewriting of HHL in the qudit formalism: quantum phase estimation, the conditional eigenvalue inversion, and the post-selection are each represented as tensor contractions that need not be unitary, so the inversion-and-projection step becomes a direct application instead of a controlled rotation followed by amplitude amplification.
If this is right
- Hyperparameter choices in HHL — clock-register size, Hamiltonian evolution time, assumed spectral bounds — have problem-dependent saturation points beyond which more resources do not help, and these can be located classically before any quantum run.
- A noise-free classical reference exists for HHL on small-to-moderate problems, against which real quantum hardware runs can be compared to isolate noise effects from algorithmic limits.
- Recasting other quantum algorithms with post-selection or controlled rotations into non-unitary tensor networks could give similarly cheap classical simulators for benchmarking.
- Gate-level simulators may be the wrong tool for evaluating algorithmic behavior of HHL-class routines, since they pay reversibility costs that the algorithm's output does not depend on.
Where Pith is reading between the lines
- The 'upper bound' framing is most defensible as a bound on the linear-algebraic content of HHL; the gap between this bound and what a real device achieves is itself a useful diagnostic of where quantum overhead actually lives.
- If the non-unitary contraction cost scales with bond dimension tied to the matrix's spectral structure, the simulator will likely be efficient exactly on the matrices where HHL itself is efficient — and inefficient on the hard cases, mirroring the dequantization literature.
- The saturation points reported for the clock register may give a practical rule for sizing phase-estimation registers on hardware without trial-and-error calibration.
- The same construction should extend to variants like preconditioned or block-encoded HHL, providing a uniform classical baseline across the family.
Load-bearing premise
That replacing HHL's unitary, post-selected steps with direct non-unitary contractions still simulates HHL itself — rather than an idealized linear solve that skips the very costs (success probability, amplification overhead, inversion conditioning) that govern HHL on real hardware.
What would settle it
Run the tensor-network simulator and a faithful gate-level HHL on the same input matrix while tracking the post-selection success probability and the conditional-rotation accuracy explicitly; if the simulator's output differs from the gate-level output once those quantum-only costs are accounted for, or if its reported hyperparameter saturation points do not appear in the gate-level run, the claim that it bounds HHL's performance fails.
Figures
read the original abstract
This work presents a new approach for simulating the HHL linear systems of equations solver algorithm with tensor networks. First, a novel HHL in the qudits formalism, the generalization of qubits, is developed, and then its operations are transformed into an equivalent classical HHL, taking advantage of the non-unitary operations that they can apply. The main novelty of this proposal is to perform a classical simulation of the HHL as efficiently as possible to benchmark the algorithm steps according to its input parameters and the input matrix. The algorithm is applied to three classical simple simulation problems, comparing it with an exact inversion algorithm, and its performance is compared against an implementation of the original HHL simulated in the Qiskit framework, providing both codes. It is also applied to study the sensitivity of the HHL algorithm with respect to its hyperparameter values, reporting the existence of saturation points and maximal performance values. The results show that this approach can achieve a promising performance in computational efficiency to simulate the HHL process without quantum noise, providing a higher bound for its performance.
Editorial analysis
A structured set of objections, weighed in public.
Referee Report
Summary. The manuscript proposes a tensor-network classical simulator of the HHL linear systems algorithm. The authors first recast HHL in a qudit formalism and then map the unitary qudit operations to an equivalent classical pipeline of (generally non-unitary) tensor contractions. The simulator is applied to three small linear-solve test problems, compared against an exact inversion baseline and against a gate-level HHL implementation in Qiskit, and used to scan HHL hyperparameters (e.g., the rescaling constant C, QPE register size) to identify saturation points and maximal-performance regimes. The authors claim the resulting framework provides a noise-free upper bound on HHL performance and a tool for benchmarking.
Significance. If the simulator faithfully reproduces HHL's input/output behavior including its characteristic resource costs, the contribution is useful: a tensor-network reference implementation that scales to problem sizes beyond gate-level state-vector simulation, and that exposes hyperparameter sensitivities (saturation in C, in QPE register depth) that are difficult to map out on noisy hardware. Released code for both the TN simulator and the Qiskit baseline is a concrete reproducibility strength and should be credited. The qudit-form recasting of HHL may also have pedagogical value independent of the simulator. The significance, however, depends sensitively on whether "HHL performance" as measured here includes the post-selection success probability that dominates the algorithm's true scaling; this is a load-bearing point (see major comments).
major comments (4)
- [Abstract / non-unitary mapping] The central methodological move — replacing unitary qudit operations with 'equivalent' non-unitary classical contractions — needs an explicit statement of what is preserved and what is dropped. In genuine HHL, the only user-visible non-unitary step is the ancilla measurement after the controlled R_y(2 arcsin(C/λ)) rotation; the success probability p ≈ Σ|β_j|²(C/λ_j)² (O(1/κ²) bare, O(1/κ) with amplitude amplification) is the dominant cost driver. The manuscript should state explicitly whether the TN simulator (i) applies the controlled rotation, projects onto |1⟩_ancilla, and records p so that reported runtimes are normalized as t_contract/p (or t_contract·κ with AA), or (ii) contracts directly to the post-selected branch and renormalizes without paying p. Under (ii), the runtime comparison with Qiskit is not a like-for-like benchmark.
- [Comparison with Qiskit HHL / 'higher bound for performance'] The claim that the TN approach provides an upper bound on HHL performance is only meaningful if both implementations are charged the same costs. Please report, for each test problem, the empirical p (success probability of the ancilla post-selection) for the Qiskit run and either (a) divide TN wall-clock by the same p, or (b) demonstrate that the TN contraction includes that factor. Without this, the speedup over Qiskit may reflect skipping the post-selection cost rather than a genuine simulation advantage.
- [Hyperparameter saturation analysis] The reported saturation points in C and the QPE register size t are presented as properties of HHL. These quantities, however, jointly control the bias of the eigenvalue inversion and the success probability p. If p is not tracked, the observed 'saturation' could be an artifact of a normalized solve in which increasing t no longer reduces solution error but would still be paying an exponentially growing circuit cost (and changing p) on a real device. The manuscript should display p (or an equivalent resource proxy) alongside solution fidelity in every hyperparameter sweep, otherwise the conclusions about optimal HHL hyperparameters do not transfer to actual HHL execution.
- [Test problems and scope of claims] Three 'classical simple simulation problems' is a thin empirical base for general claims about HHL's input-parameter sensitivity. Please specify the matrix sizes, condition numbers κ, sparsity, and eigenvalue spectra, and either restrict the conclusions to this regime or add at least one family of problems where κ is varied systematically — this is necessary to support the saturation/maximal-performance claims, since κ is the parameter HHL's behavior is most sensitive to.
minor comments (4)
- [Terminology] 'Higher bound for performance' is ambiguous — recommend 'upper bound on achievable performance in the absence of quantum noise' (or similar) to avoid conflation with lower/upper bound usage in complexity statements.
- [Qudit formalism] Make explicit at the outset whether the qudit recasting is a presentation device for the TN map or is intended as an independently meaningful generalization of HHL; the abstract reads ambiguously on this point.
- [Code release] Please ensure the released code includes the exact seeds, problem instances, and Qiskit version used; HHL Qiskit timing is sensitive to backend transpilation defaults and should be documented.
- [Figures (sweeps)] When showing saturation curves, plot solution error and resource proxy on twin axes so that the saturation point can be identified relative to both.
Simulated Author's Rebuttal
We thank the referee for a careful and constructive report. The central thread of the report — that HHL's true cost is dominated by the ancilla post-selection probability p, and that any "performance" claim must charge both the tensor-network (TN) simulator and the Qiskit baseline the same cost — is well taken. We agree that the manuscript, as written, does not make sufficiently explicit (i) what the TN contraction preserves vs. drops relative to the unitary HHL pipeline, and (ii) how p is (or is not) accounted for in our timings and hyperparameter sweeps. We will revise to address these points directly: by stating the post-selection accounting explicitly, by reporting p alongside fidelity in every sweep, by re-doing the Qiskit comparison on a like-for-like basis, and by tightening the scope of the saturation/maximal-performance claims to the regime actually probed by our test problems (with at least one κ-controlled problem family added). The qudit reformulation and released code are unchanged; the revisions affect interpretation, plots, and scope of claims rather than the core construction.
read point-by-point responses
-
Referee: The non-unitary 'equivalent' classical contractions need an explicit statement of what is preserved and what is dropped. In particular, does the TN simulator apply the controlled R_y rotation, project onto |1⟩_ancilla, and record p, or does it contract directly to the post-selected branch and renormalize without paying p?
Authors: The referee has identified the description correctly: our TN pipeline implements case (ii). The controlled R_y(2 arcsin(C/λ)) is represented exactly in the qudit-form contraction, but the ancilla projection onto |1⟩ is folded into the contraction analytically and the resulting (sub-normalized) branch state is renormalized at readout. We do not stochastically sample the ancilla, and the wall-clock figures in the current manuscript do not include a 1/p (or κ, with amplitude amplification) factor. We agree this must be stated up front. In revision we will: (a) add an explicit subsection 'What the TN map preserves and what it drops', stating that unitarity along the ancilla branch is replaced by deterministic projection + renormalization, and that the post-selection success probability p is computed as a by-product (it equals the squared norm of the un-normalized post-projection branch) but was not previously charged to the runtime; (b) report p for every TN run, and present runtimes both as raw t_contract and as the post-selection-charged t_contract/p (and t_contract·κ as an AA-style proxy). This reframes the simulator as a noise-free reference for the *coherent* portion of HHL, with p tracked separately rather than hidden. revision: yes
-
Referee: The 'upper bound on HHL performance' / Qiskit comparison is only meaningful if both implementations are charged the same costs. Report empirical p for each Qiskit run and either divide TN wall-clock by the same p or show TN already includes it.
Authors: Agreed. As noted above, the present TN timings do not include the 1/p factor, so the comparison in the current draft is not like-for-like in the sense the referee requires. We will revise the comparison table for each of the three test problems to include: (i) the empirical post-selection probability p_Qiskit measured from the Qiskit shot statistics; (ii) the analytic p_TN extracted from the contracted branch norm (these should agree up to discretization in the QPE register, which itself becomes a useful cross-check); (iii) raw TN contraction time, and (iv) post-selection-charged TN time t_contract/p alongside the Qiskit total time. We will rephrase the abstract and conclusions: the TN simulator provides a noise-free reference for the coherent pipeline and a tighter wall-clock cost for the *simulation* than gate-level state-vector simulation, but it is not a 'higher bound for [HHL] performance' in the algorithmic-complexity sense once p is charged. We will remove or qualify that phrasing. revision: yes
-
Referee: Hyperparameter saturation in C and QPE register size t may be artifacts of a normalized solve. Display p (or an equivalent resource proxy) alongside solution fidelity in every hyperparameter sweep.
Authors: We accept this point. The saturation behavior we report is in solution fidelity (overlap with the exact x = A⁻¹b) as C and t are varied. The referee is correct that fidelity saturation alone does not capture the joint behavior with p: increasing t past the saturation point does not improve fidelity but does change p (and would multiply circuit depth on hardware). In the revised manuscript every C-sweep and t-sweep figure will be replaced by a two-panel plot showing fidelity and p (and, derived from these, an effective resource proxy fidelity·p or t_contract/p) on the same horizontal axis. We will rewrite the discussion of 'optimal hyperparameters' to identify the C and t at which the joint metric — not fidelity alone — is optimized, and we will explicitly note where the fidelity-only optimum differs from the resource-aware optimum. revision: yes
-
Referee: Three 'classical simple simulation problems' is a thin empirical base. Specify sizes, condition numbers κ, sparsity, and spectra, and either restrict the claims or add at least one family with κ varied systematically.
Authors: We will tighten this in two ways. First, for the three existing test problems we will tabulate matrix size N, sparsity, full eigenvalue spectrum, condition number κ, and the chosen rescaling C, so the regime is unambiguous. Second, we will add a parametric problem family in which κ is varied systematically while N and sparsity are held fixed (a tridiagonal/diagonal family with eigenvalues placed to sweep κ over roughly one to two decades within the range our TN contractions handle), and report fidelity, p, and runtime as functions of κ. We will then restrict the saturation/maximal-performance language to the regime covered by these experiments and explicitly flag extrapolation to large κ or large N as open. We expect this to convert the current qualitative claims into quantitative, regime-bounded ones, which is what the referee is asking for. revision: yes
- We cannot, within the scope of this revision, demonstrate that the TN simulator scales to problem sizes substantially beyond gate-level state-vector simulation for arbitrary κ; the κ-sweep family we will add is bounded by the contraction cost we can run, and we will state this limitation rather than claim general scalability.
Circularity Check
No significant circularity visible from the abstract; the reader's concern is a fidelity/scope question (does the TN contraction faithfully include ancilla post-selection?), not a definitional loop.
full rationale
Only the abstract is available, so a full derivation-chain audit is not possible. From what is given, the paper's logic is: (i) recast HHL in qudit form; (ii) replace unitary blocks with equivalent non-unitary tensor contractions; (iii) benchmark the resulting classical simulator against Qiskit's gate-level HHL on three test problems and against an exact inverse. None of these steps, as described, fit the circularity templates: there is no parameter fitted to a subset of data and then re-reported as a prediction; the comparison target (Qiskit HHL, exact inversion) is external to the simulator being built; there is no invocation of an authors' "uniqueness theorem" forcing the construction; and no ansatz is imported via self-citation. The claim "higher bound for performance" is a comparative empirical statement against an external baseline, not a tautology. The reader's load-bearing attack — that the non-unitary contraction may silently absorb the ancilla post-selection probability p ≈ O(1/κ²), so that the simulator computes A⁻¹|b⟩ without paying HHL's defining cost — is a real and substantive worry, but it is a *correctness/scope* concern (is the benchmarked workload actually HHL?) rather than a *circularity* concern (does the conclusion reduce to the input by definition?). Even in the worst case described by the skeptic, the simulator would be solving a related-but-different procedure and comparing it to Qiskit HHL; that is a category/fidelity error, not a self-definitional loop. It would only become circular if, e.g., the "saturation points" being reported were definitionally equivalent to the rescaling constant C that was used to set them up — and we cannot verify that from the abstract alone. Accordingly, score 1: a small allowance for the inability to inspect the body, with no concrete circular step quotable from the available text. The substantive risk flagged by the reader belongs under correctness, per the hard rules.
discussion (0)
Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.