An Early Investigation of the HHL Quantum Linear Solver for Scientific Applications

Abstract

In this paper, we explore using the Harrow–Hassidim–Lloyd (HHL) algorithm to address scientific and engineering problems through quantum computing, utilizing the NWQSim simulation package on a high-performance computing platform. Focusing on domains such as power-grid management and climate projection, we demonstrate the correlations of the accuracy of quantum phase estimation, along with various properties of coefficient matrices, on the final solution and quantum resource cost in iterative and non-iterative numerical methods such as the Newton–Raphson method and finite difference method, as well as their impacts on quantum error correction costs using the Microsoft Azure Quantum resource estimator. We summarize the exponential resource cost from quantum phase estimation before and after quantum error correction and illustrate a potential way to reduce the demands on physical qubits. This work lays down a preliminary step for future investigations, urging a closer examination of quantum algorithms’ scalability and efficiency in domain applications.

1. Introduction

Starting with the Deutsch–Jozsa algorithm and Shor’s discrete logarithm algorithm [1,2], the potential of quantum computing algorithms has extended beyond merely simulating quantum systems. The potential speedup of quantum algorithms over their classical counterparts has gathered tremendous attention, including a fundamental demand in science and engineering: solving linear systems. Harrow, Hassidim, and Lloyd (HHL) first developed a quantum linear solver with an exponential speedup in problem dimensions in [3]. Built upon the exponential speedup of quantum linear system algorithms (QLSAs), many works have explored theoretical quantum advantages in various applications. These fields include portfolio optimization [4], machine learning [5,6], differential equation solving [7], linear optimization [8,9,10,11], and semi-definite optimization [12,13].

However, the HHL algorithm proposed in [3] has a quadratic dependency on matrix condition number and matrix sparsity, worse than classical linear solvers such as factorization methods and conjugate gradient, where condition number is the product of the norm of the coefficient matrix and the norm of the inverse matrix. Several works have been proposed to reduce the dependency on the condition number of coefficient matrices and the accuracy of the solution state [14,15,16,17,18,19,20,21,22]. Specifically, based on adiabatic theorems, the state of the art has a linear or quasi-linear dependency on the condition number and a logarithmic dependency on the inverse of the solution accuracy [18,19,20,22].

The HHL algorithm has been demonstrated in experiments to solve linear algebra problems. The largest linear systems demonstrated on real gate-based quantum machines are up to $4\times 4$ systems with variants of the HHL algorithm [23,24,25] and an $8\times 8$ system with the linear solver based on adiabatic quantum computing [26]. However, testing QLSAs on real quantum devices to demonstrate a quantum advantage still suffers from multiple obstacles, such as the large number of required quantum gates and the high noise level of current quantum devices [27].

With the current development of quantum hardware and exploration of quantum error correction (QEC) codes, a large-scale fault-tolerant quantum computer is expected to be demonstrated in the foreseeable future [28,29,30,31,32,33,34]. QEC codes, such as surface codes, are expected to detect and correct Pauli errors, as well as any linear combinations of them, provided the errors occur below a certain threshold probability [35]. Although the gap between algorithm requirements and hardware specifications is shrinking, the gap still exists, which necessitates the analysis of the resource costs involved [36]. Resource estimations have been performed for chemistry [37], Grover’s algorithm on the Advanced Encryption Standard [38], Shor’s discrete logarithm algorithm for the RSA cryptosystem [39], and the computation of elliptic curve discrete logarithms [40]. However, despite this being essential for understanding the disparity between hardware capabilities and practical applications, there is limited work on non-asymptotic resource estimation for QLSAs [41].

In this paper, we focus on resource estimation and experiment with the HHL algorithm on several applications selected from domain science, such as power grid and climate projection. Different from the previous works about asymptotic and non-asymptotic resource analysis [3,14,15,16,17,18,19,20,21,22,41], we investigate the factors affecting the final accuracy, resource cost, and fault-tolerant hardware requirements. Our experiments show the effectiveness of the HHL algorithm in scientific applications with a low accuracy in quantum phase estimation. Working with the Microsoft Azure Quantum resource estimator [42,43], we summarize the exponential dependency of quantum resources on the number of clock qubits in HHL circuits and demonstrate a possible method to reduce the demands on physical qubits in fault-tolerant quantum computing.

This paper is organized as follows: Section 2 introduces the idea of quantum linear system solvers, with implementation-related details. Section 3 presents the simulator, NWQSim [44], and the resource estimation tool. Next, we explore the factors of interest in evaluating numerical experiments in Section 4 and perform those experiments in Section 5. Finally, we discuss the limitations in Section 6 and conclude the implications of our work on domain science applications in Section 7.

2. Quantum Linear Systems and the Implementation of the Solver

2.1. Overview of the Harrow–Hassidim–Lloyd (HHL) Algorithm

Quantum information is encoded into the state of quantum systems. Here, we assume all relevant quantum states can be represented as statevectors. An $n_d$-qubit statevector $|x\rangle ={\sum }_{j=0}^{2^{n_d}-1}{\alpha }_j|\overrightarrow{j}\rangle$ is a normalized complex vector, i.e., ${\alpha }_j\in \mathbb{C}$ for all j and ${\sum }_{j=0}^{2^{n_d}-1}{|{\alpha }_j|}^2=1$, while $\overrightarrow{j}\in {\{0,1\}}^{n_d}$ is the number j as a binary string. The set $\{|\overrightarrow{j}\rangle \}$ forms the basis set of ${\mathbb{C}}^{2^{n_d}}$, referred to as the computational basis. Specifically, $|\overrightarrow{j}\rangle$ is the unit vector whose ${(j+1)}^{\mathrm{th}}$ entry is 1 and other entries are 0. The notation $\langle \overrightarrow{j}|$ is the conjugate transpose of $|\overrightarrow{j}\rangle$.

Definition 1

(A quantum linear-system problem). A quantum linear-system problem is to solve a system of linear equations with a normalized solution vector $|x\rangle =A^{-1}|b\rangle /{\parallel A^{-1}|b\rangle \parallel }_2$ where coefficient matrix $A\in {\mathbb{C}}^{N\times N}$ is Hermitian and $|x\rangle$ and $|b\rangle$ are both normalized vectors.

Start with a classical complex linear system $A\overrightarrow{x}=\overrightarrow{b}$, $A\in {\mathbb{C}}^{N\times N}$, where the right-hand-side (RHS) vector $\overrightarrow{b}$ is normalized to obtain $|b\rangle :=\overrightarrow{b}/{\parallel \overrightarrow{b}\parallel }_2$; then, a quantum linear-system problem can be formed with A and $|b\rangle$ if A is Hermitian. Otherwise, a larger linear system can be constructed as follows [3]:

$$\begin{array}{c}\hfill \left[\begin{array}{cc}\mathbf{0}& A\\ A^{†}& \mathbf{0}\end{array}\right]\left[\begin{array}{c}\overrightarrow{0}\\ |x\rangle \end{array}\right]=\left[\begin{array}{c}|b\rangle \\ \overrightarrow{0}\end{array}\right],\end{array}$$

(1)

where ${·}^{†}$ is the conjugate transpose. Therefore, we assume coefficient matrices are Hermitian in the rest of this paper. Since the data is encoded into qubits, if the dimensions of A and $\overrightarrow{b}$ are not in the power of 2, A and b must be expanded. Suppose there exists a quantum linear system solver that obtains $|x\rangle =A^{-1}|b\rangle /{\parallel A^{-1}|b\rangle \parallel }_2$ from the circuit; then the original solution of the system can be recovered by $\overrightarrow{x}={\parallel b\parallel }_2{\parallel A^{-1}|b\rangle \parallel }_2|x\rangle$. While ${\parallel b\parallel }_2$ is known from the previous computation, the solver needs to provide the value of $\parallel A^{-1}{|b\rangle \parallel }_2$.

2.1.1. Mathematical Foundation of HHL

Harrow, Hassidim, and Lloyd first developed the HHL algorithm to solve the quantum linear-system problem [3]. The fundamental idea behind the HHL algorithm is that the eigenstates of the Hermitian matrix A (noted as $\{|v_j\rangle \}$) form a complete orthonormal basis of ${\mathbb{C}}^N$ (i.e., $\langle v_j|v_k\rangle ={\delta }_{jk}$), and hence the state $|b\rangle$ can always be decomposed by this basis as $|b\rangle ={\sum }_{j=0}^{N-1}{b}_j|v_j\rangle$. Similarly,

$$\begin{array}{cc}\hfill |x\rangle & ={\displaystyle \frac{A^{-1}|b\rangle }{\parallel A^{-1}{|b\rangle \parallel }_2}}\hfill \\ \hfill & ={\displaystyle \frac{1}{\parallel A^{-1}{|b\rangle \parallel }_2}}\sum _{j=0}^{N-1}{\displaystyle \frac{1}{{\lambda }_j}}|v_j\rangle \langle v_j|\sum _{j=0}^{N-1}{b}_j|v_j\rangle \hfill \\ \hfill & ={\displaystyle \frac{1}{\sqrt{{\sum }_{j=0}^{N-1}\frac{|b_j{|}^2}{{\lambda }_j^2}}}}\sum _{j=0}^{N-1}{\displaystyle \frac{b_j}{{\lambda }_j}}|v_j\rangle .\hfill \end{array}$$

(2)

In other words, the HHL algorithm needs a quantum computer to perform eigen-decomposition of A and eigenvalue inversion. Figure 1 shows a general description of the circuit that exactly serves the purpose, with an additional $n_d$-qubit data-loading block to load $|b\rangle$ into the quantum computer and $n_d=\lceil \log \left(N\right)\rceil$.

2.1.2. Quantum Phase Estimation

The eigen-decomposition requires a subroutine called quantum phase estimation (QPE), as illustrated in the sky blue part of Figure 1. Given a unitary matrix U has an eigenstate $|v_j\rangle$ with eigenvalue $e^{2\pi i{\theta }_j}$, QPE is a quantum algorithm to solve the phase of the eigenvalue (${\theta }_j$) [35]. After executing the QPE algorithm, the binary representation of the phase angle $\theta$ is stored in a qubit state. The qubits carrying the phase information are named “clock qubits”. In the HHL algorithm, if $|v_j\rangle$ is an eigenstate of a Hermitian matrix A with eigenvalue ${\lambda }_j$, by constructing a unitary matrix $U=e^{itA}$ with a scale factor t, the state $|v_j\rangle$ becomes an eigenstate of U with eigenvalue $e^{it{\lambda }_j}$. Therefore, the eigenvalue ${\lambda }_j$ can be estimated using the QPE algorithm.

Suppose we have access to the gate U; then it is clear that $U^l|v_j\rangle =e^{2\pi i{\theta }_{j}l}|v_j\rangle$ for some positive integer l. QPE requires a submodule called quantum Fourier transform (QFT). QFT maps

$$\begin{array}{cc}\hfill QFT|\overrightarrow{j}\rangle & ={\displaystyle \frac{1}{\sqrt{2^{n_c}}}}\sum _{k=0}^{2^{n_c}-1}{\omega }^{jk}|\overrightarrow{k}\rangle \hfill \\ \hfill & ={\displaystyle \frac{1}{\sqrt{2^{n_c}}}}\left(|0\rangle +e^{2\pi i0.j_{n_c}}|1\rangle \right)\left(|0\rangle +e^{2\pi i0.j_{n_c-1}{j}_{n_c}}|1\rangle \right)\dots \left(|0\rangle +e^{2\pi i0.j_1{j}_2\dots j_{n_c}}|1\rangle \right)\hfill \end{array}$$

where $\overrightarrow{j}$ has $n_c$ bits and $\omega =e^{2\pi i/\left(2^{n_c}\right)}$. Intuitively, $\overrightarrow{j}$ can be considered as binary number $\overrightarrow{j}=j_1{j}_2\dots j_{n_c}$ such that $j_l\in \{0,1\}$ and QFT transforms this binary number from a state to the phases of bases in different accuracy. So, on the contrary, if we apply the inverse of the QFT operator, denoted by $QF{T}^{†}$, the phase value becomes a state, and we can measure the state to obtain the phase value in the binary representation.

To summarize the process of a standalone QPE routine, we have

$$\begin{array}{cc}\hfill {|0\rangle }^{\otimes n_c}|v_j\rangle & \stackrel{H^{\otimes n_c}}{\to }{\displaystyle \frac{1}{\sqrt{2^{n_c}}}}\sum _{k=0}^{2^{n_c}-1}|\overrightarrow{k}\rangle |v_j\rangle \hfill \\ \hfill & \stackrel{CU\mathrm{sequence}}{\to }{\displaystyle \frac{1}{\sqrt{2^{n_c}}}}\sum _{k=0}^{2^{n_c}-1}{e}^{2\pi i{\theta }_{j}k}|\overrightarrow{k}\rangle |v_j\rangle \hfill \\ \hfill & \stackrel{QF{T}^{†}}{\to }|{\tilde{\theta }}_j\rangle |v_j\rangle \hfill \end{array}$$

where the $CU\mathrm{sequence}$ is the controlled-U sequence in the sky blue part of Figure 1 and ${\tilde{\theta }}_j={\theta }_j$ if ${\theta }_j$ can be perfectly represented in $n_c$ bits; otherwise, ${\tilde{\theta }}_j$ is an estimation of ${\theta }_j$ in a finite accuracy. In other words, the number of clock qubits, $n_c$, governs the accuracy of the estimated eigenvalue in QPE. To understand more details about QFT and QPE, we direct the interested reader to [35,45].

Note that, without circuit optimization, the increase in $n_c$ will exponentially increase the gate counts in HHL circuits. Recall the HHL circuit in Figure 1: an extra clock qubit leads to an extra controlled $U^{2^{n_c-1}}$ and an extra controlled inverse $U^{2^{n_c-1}}$ in the HHL circuit, where $U=e^{itA}$ and A is the coefficient matrix in a linear system. Generally, we should not explicitly compute the matrix $U^{2^{n_c-1}}$, but apply gate U for $2^{n_c-1}$ times in the circuit. Then, the QPE part of the circuit contains ${\sum }_{j=0}^{n_c-1}{2}^j=2^{n_c}-1$ number of U, and when there are $n_c+1$ clock qubits, an extra $2^{n_c}$ number of U is added into the QPE, which almost doubles the number of gates U in QPE. The same situation happens on the inverse QPE part of the HHL circuit.

2.1.3. State Evolution in HHL

In general, the evolution of states in the HHL circuit is

$$\begin{array}{cc}\hfill |0\rangle {|0\rangle }^{\otimes n_c}|0^{n_d}\rangle & \stackrel{\mathrm{Data}\mathrm{loading}}{\to }|0\rangle {|0\rangle }^{\otimes n_c}|b\rangle \hfill \\ \hfill & \stackrel{\mathrm{QPE}}{\to }\sum _{j=0}^{2^{n_d}-1}{b}_j|0\rangle |{\tilde{\lambda }}_j\rangle |v_j\rangle \hfill \\ \hfill & \stackrel{Eigenvalue Inversion}{\to }\sum _{j=0}^{2^{n_d}-1}{b}_j\left(\sqrt{1-{\displaystyle \frac{C^2}{{\tilde{\lambda }}_j^2}}}|0\rangle +{\displaystyle \frac{C}{{\tilde{\lambda }}_j}}|1\rangle \right)|{\tilde{\lambda }}_j\rangle |v_j\rangle \hfill \\ \hfill & \stackrel{Measure the ancillary only keep |1\rangle }{\to }D\sum _{j=0}^{2^{n_d}-1}{\displaystyle \frac{b_j}{{\tilde{\lambda }}_j}}|1\rangle |{\tilde{\lambda }}_j\rangle |v_j\rangle \hfill \\ \hfill & \stackrel{{\mathrm{QPE}}^{†}}{\to }D|1\rangle |0^{n_c}\rangle \sum _{j=0}^{2^{n_d}-1}{\displaystyle \frac{b_j}{{\tilde{\lambda }}_j}}|v_j\rangle \approx D|1\rangle |0^{n_c}\rangle |x\rangle \hfill \end{array}$$

where ${\tilde{\lambda }}_j\approx {\lambda }_j$ is the eigenvalue of A with a finite accuracy estimated in QPE, and C and D are both constant normalization factors

$$\begin{array}{c}\hfill D={\displaystyle \frac{C}{\sqrt{{\sum }_{j=0}^{2^{n_d}-1}{C}^2\frac{|b_j{|}^2}{{\tilde{\lambda }}_j^2}}}}\approx {\displaystyle \frac{1}{\parallel A^{-1}{|b\rangle \parallel }_2}}.\end{array}$$

Thus, the norm $\parallel A^{-1}{|b\rangle \parallel }_2$ can be estimated by the probability of measuring the ancillary qubit in state $|1\rangle$, i.e., $\parallel A^{-1}{|b\rangle \parallel }_2\approx \sqrt{\mathrm{Pr}\left(\mathrm{Measure}1\mathrm{in}\mathrm{ancillary}\right)}$. This value can be obtained without extra cost as we need to run the circuit multiple times to get $|x\rangle$ or $\langle x|M|x\rangle$ for some observable M. The overall runtime complexity of HHL algorithm is $\tilde{O}(\log \left(N\right)s^2{\kappa }^2/ϵ)$, where s is the sparsity of A, $\kappa =\parallel A\parallel \parallel A^{-1}\parallel$ is the condition number of A, and $ϵ$ is the final additive error of the solution defined by the ideal state $|x\rangle$ and the result from HHL $|x_{HHL}\rangle$ through $\parallel |x\rangle -|x_{HHL}\rangle \parallel \le ϵ$ [3].

2.1.4. Quantum-Classical Data Exchange in HHL

There are two major input models for encoding both matrix A (or $e^{itA}$) and vector $|b\rangle$ into a quantum computer. One is the sparse-access model, used in the HHL algorithm [3]. The sparse-access model is a quantum version of classical sparse matrix computation, and we assume access to unitaries that calculate the index of the $l^{\mathrm{th}}$ non-zero element of the $k^{\mathrm{th}}$ row of a matrix A when given $(k,l)$ as input. A different input model, now known as the quantum operator input model, is from Low and Chuang [46]. This method is based on the block-encoding of A to allow efficient access to entry values. Its circuit implementation can be found in [47,48]. Meanwhile, this encoding scheme can also be achieved using quantum random access memory [49,50,51,52]. It requires the complexity $O\left(\mathrm{polylog}\left(N/{ϵ}_{BE}\right)\right)$ for realizing an ${ϵ}_{BE}$-approximate block-encoding of $A\in {\mathbb{C}}^{N\times N}$ with quantum random access memory [50].

Definition 2

(The block-encoding of a matrix). The block-encoding of a matrix $A\in {\mathbb{C}}^{N\times N}$ is a unitary operator U such that

$$\begin{array}{c}\hfill U=\left[\begin{array}{cc}A/a& ·\\ ·& ·\end{array}\right]\end{array}$$

where $a\ge \parallel A\parallel$ is a normalizing constant. In other words, U and A satisfy, for some constant a and n,

$$\begin{array}{c}\hfill a\left({\langle 0|}^{\otimes n}\otimes I_N\right)U\left(I_N\otimes {|0\rangle }^{\otimes n}\right)=A\end{array}$$

where $I_N\in {\mathbb{R}}^{N\times N}$ is the identity matrix.

To construct the matrix exponential $e^{itA}$ in QPE via block-encoding-based methods, block-encoding first embeds the coefficient matrix A into a larger unitary matrix, and then uses Quantum Signal Processing to achieve the Hamiltonian simulation $e^{itA}$ [53]. However, limited by the size of tested matrices in our numerical experiments, block-encoding alone already does not show advantages over Quantum Shannon Decomposition (QSD), a method that directly decomposes $e^{itA}$ into a sequence of basis gates, in terms of gate counts and the number of encoding qubits. We illustrate this in

Table 1. Resource costs of using FABLE [47] to block-encode A and QSD to synthesize $e^{2\pi iA}$.

Linear System	Problem Dimension	Method	# of Qubits	# of $\mathit{CX}$	# of ${{\mathit{U}}_3}^1$
Section 5.1 Iter. 1	$5\times 5$	QSD	4	100	208
		FABLE	7	73	70
Section 5.2 Three-point	$9\times 9$	QSD	4	100	208
		FABLE	9	268	264
Section 5.2 Five-point	$25\times 25$	QSD	5	444	904
		FABLE	11	1039	1034

¹ $U_3$ gate is the 1-qubit rotation gates with 3 Euler angles.

. Note that the coefficient matrix used in Section 5.1 is non-Hermitian, so its conversion to a Hermitian matrix using Equation (1) brings a disadvantage to QSD in terms of the number of gates.

On the other hand, efficiency in reading $|x\rangle$ could be a potential threat to quantum speedup. The current state-of-the-art quantum state tomography algorithm is from Apeldoorn et al. [54]. For a state $|\psi \rangle ={\sum }_{j=0}^{N-1}{\beta }_j|\overrightarrow{j}\rangle \in {\mathbb{C}}^N$, with probability $1-\delta$, the pure-state tomography in [54] requires $O\left(\sqrt{N}/\sigma ·\log \left(N/\delta \right)\right)$ queries to the unitary oracle that prepares $|\psi \rangle$ from $|00\dots 0\rangle$ to output a vector ${\overrightarrow{\beta }}_{est}\in {\mathbb{R}}^N$ such that $\parallel \Re \left(\overrightarrow{\beta }\right)-{\overrightarrow{\beta }}_{est}{\parallel }_{\infty }\le \sigma$. The same routine can be applied to $i|\psi \rangle$ to estimate the imaginary part.

2.2. Implementation of the Circuit Generation

In all experiments in this paper, the code for the HHL circuit generation comes from a Qiskit-based open-sourced package [55], which only produces the essential parts of the HHL circuit as colored in Figure 1. We made slight modifications to accommodate the changes in Qiskit 0.46. The state preparation for $|b\rangle$ uses the algorithm in [56] that decomposes an arbitrary isometry into the optimized number of single-qubit and CNOT gates, where isometry refers to the inner-product-preserving transformation that maps between two Hilbert spaces; i.e., the state preparation is a special case of isometries. To construct the unitary operator $e^{itA}$ in the QPE stage, the code directly uses Quantum Shannon Decomposition to synthesize the matrix exponential in the circuit.

3. Simulator and Resource Estimation Tool

The statevector simulator carries the simulations in the experiments, SV-Sim [57], in Northwest Quantum Circuit Simulation Environment (NWQSim)(V2.5.0) [44]. As shown in [57], compared to simulators in Aer from Qiskit [58] and qsim from Cirq [59], NWQSim provides specialized computation for a wide range of supported basis gates and architectures of CPUs and GPUs, such as gate fusion. In

Table 2. HHL circuit properties for four random examples.

No. of Qubits		CX Gates	Depth	Total No. of Gates
${\mathit{n}}_{\mathit{d}}$	${\mathit{n}}_{\mathit{c}}$			Before Fusion	After Fusion
4	6	116,535	248,084	325,189	70,804
5	7	1,111,178	2,373,842	3,106,244	665,921
6	8	9,335,345	19,969,964	26,117,061	5,557,777
7	9	78,420,632	167,816,254	219,386,270	46,631,320

and later in Section 5, we demonstrate that the gate fusion strategy in NWQSim can reduce about $80\%$ of gates in the circuits without sacrificing error rates. On the other hand, NWQSim utilizes a communication model called “PGAS-based SHMEM” that significantly reduces communication latency for intra-node CPUs/GPUs and inter-node CPU/GPU clusters. In this case, SV-Sim has an exceptional performance over other simulators in deep-circuit simulation [57]. Figure 2 shows the running time of the HHL circuit in the size of 11 qubits to 17 qubits on SV-Sim on four different GPUs.

The resource estimator in [42,43] from Microsoft Azure Quantum establishes a systematic framework to access and model the resources necessary for implementing quantum algorithms on a user-specified fault-tolerant scenario. This tool enables detailed estimation of various computational resources, such as the number of physical qubits, the runtime, and other QEC-related properties to achieve a quantum advantage for certain applications. Specifically, the tool accepts a wide range of qubit and quantum error correction code specifications and an error budget that allows different error rates to simulate a described fault-tolerant environment.

The tool is compatible with circuits generated from a high-level quantum computing language or package, including Qiskit and Q#. After a circuit is given, the input is compiled into Quantum Intermediate Representation through a unified processing program, and the estimator can examine the code and record qubit allocation, qubit release, gate operation, and measurement operation. Then, logical-level resources are estimated and used to compute the required physical-level resources further. The tool returns a thorough report on resources demanded to perform the given algorithm on fault-tolerant quantum computers, including the explanation and related mathematical equations of those estimates. A selected list of estimates is described in Section 4, and their values in conducted experiments are displayed in Section 5.

4. Factors of Interest

As we focus on the linear system in scientific applications instead of random systems for benchmarking, we have less control over the specific values of matrix properties like condition numbers. Our interest is more on the number of clock qubits $n_c$ in the HHL circuit, which controls the accuracy of estimated eigenvalues. The error in eigenvalue estimation affects the solution of the linear system through Equation (2). From [35], to obtain an eigenvalue with $2^{-b}$ accuracy with at least $1-p_{QPE,fail}$ success probability using QPE, we need

$$\begin{array}{c}\hfill n_c=b+⌈{\log }_2\left(2+{\displaystyle \frac{1}{2p_{QPE,fail}}}\right)⌉.\end{array}$$

In the Qiskit-based HHL implementation that we used [55], it is suggested that

$$\begin{array}{c}\hfill n_c=max\left(n_d+1,⌈{\log }_2(\kappa +1)⌉\right)+{\mathbb{I}}_{nv}\end{array}$$

(3)

where ${\mathbb{I}}_{nv}=1$ if the coefficient matrix has a negative eigenvalue; otherwise, it is 0. In this paper, we will adjust $n_c$ to illustrate the influence of the QPE resources on the HHL circuit’s total cost and the algorithm’s accuracy in domain applications.

When discussing resource estimation under a fault-tolerant setting, our primary concerns are the estimated runtime, the number of physical qubits, and extra resources required from the QEC code. We adopt a distance-7 surface code that encodes 98 physical qubits into a single logical qubit. The theoretical logical qubit error rate is $3\times {10}^{-10}$, and the error correction threshold is 0.01. The Azure Quantum resource estimator provides several qubit parameter sets to simulate different qubit properties. The preset qubit settings we used in this paper are $(\mathrm{ns},{10}^{-4})$ and $(\mathrm{\mu }\mathrm{s},{10}^{-4})$ from [42], where the former is close to the specifications of superconducting transmon qubits or spin qubits, and the latter is more relevant for trapped-ion qubits [42]. A list of detailed configurations of qubit parameter set $(\mathrm{ns},{10}^{-4})$ and $(\mathrm{\mu }\mathrm{s},{10}^{-4})$ is in

Table 3. Qubit parameter configurations.

Qubit Parameter Set		$(\mathbf{ns},{10}^{-4})$	$(\mathbf{\mu }\mathbf{s},{10}^{-4})$
Operation Time	Measurement	100 ns	100 μs
	Single-qubit gate	50 ns	100 μs
	Two-qubit gate	50 ns	100 μs
	T gate	50 ns	100 μs
Error rate	Measurement	${10}^{-4}$	${10}^{-4}$
	Single-qubit gate	${10}^{-4}$	${10}^{-4}$
	Two-qubit gate	${10}^{-4}$	${10}^{-4}$
	T gate	${10}^{-4}$	${10}^{-6}$

. We enforce 2-D nearest-neighbor connectivity of the qubits to simulate the connectivity constraint on real quantum computers. So we also demonstrate the changes in some factors before this constraint is enforced (“pre-layout”) and after this constraint is enforced (“after layout”).

Another important tunable parameter is the overall allowed errors for the algorithm, namely error budget. Its parameter value is equally divided into three parts:

• Logical error probability: the probability of at least one logical error;
• T-distillation error probability: the probability of at least one faulty T-distillation;
• Rotation synthesis error probability: the probability of at least one failed rotation synthesis.

There are also specific breakdowns in the resource required by QEC that are of interest [42,43]. We list them in

Table 4. Factors of interest in QEC.

Factors of Interest	Description
Number of logical qubits pre- and after layout	Under the nearest-neighbor constraint, extra logical qubits could be required to satisfy the connectivity needed in the algorithm (circuit); the relation is $n_{\mathrm{after}}=2n_{\mathrm{alg}}+⌈\sqrt{8n_{\mathrm{alg}}}⌉+1$, where $n_{\mathrm{alg}}$ is the number of logical qubits pre-layout and $n_{\mathrm{after}}$ is the number of qubits after layout
Number of physical qubits for the algorithm	The product of the number of logical qubits after layout and the number of physical qubits needed to encode one logical qubit
Number of physical qubits for T factories	T factories produce T states to implement non-Clifford operations in a circuit
Number of physical qubits	The sum of the number of physical qubits for the algorithm and the number of physical qubits for T factories
Number of T states	The estimator requires 1 T state for each of the T gates in a circuit, 4 T states for each of the $CCZ$ and $CCiX$ gates, and 18 T states for each of the arbitrary single-qubit rotation gates
Number of T factories	Determined from algorithm runtime, T state per T factory, the number of T states, and T factor duration through the equation $⌈{\displaystyle \frac{T\mathrm{state}·T\mathrm{factor}\mathrm{duration}}{T\mathrm{state}\mathrm{per}T\mathrm{factory}·\mathrm{algorithm}\mathrm{runtime}}}⌉$
Number of logical cycles for the algorithm	The logical depth of the algorithm
Min. logical qubit error rate required to run the algorithm within the error budget	${\displaystyle \frac{\mathrm{logical}\mathrm{error}\mathrm{probability}}{\mathrm{Number}\mathrm{of}\mathrm{logical}\mathrm{qubits}·\mathrm{Number}\mathrm{of}\mathrm{logical}\mathrm{cycles}}}$
Min. T state error rate required for distilled T states	${\displaystyle \frac{T\mathrm{distillation}\mathrm{error}\mathrm{probability}}{\mathrm{Total}\mathrm{number}\mathrm{of}T\mathrm{states}}}$

.

5. Scientific Applications and Evaluation

This section examines the utilization of the HHL algorithm in the fields of power grids and climate projection. We evaluate the performance of HHL in terms of solution accuracy, resource cost, and influence on convergence speed for applicable problems.

In addition to the hardware specifications in Section 3, all resource estimator jobs are run on the Azure Quantum cloud server. Due to the limitation on the cloud service usage, we cannot examine some of the deepest circuits in this section with the resource estimator, and all evaluated circuits are transpiled.

With respect to a given basis gate set from the estimator using the transpiler in Qiskit. The optimization level of the transpiler is set to level 2. The Qiskit version is 0.46. The Azure Quantum version is 0.30.0. The MATPOWER version is 7.1.

5.1. Power Flow Problem in Power Grid

The use of quantum algorithms has drawn much attention in recent research on power system applications, especially the areas where quantum linear system solver can be deployed, including power flow, contingency analysis, state estimation, and transient simulation [60,61,62,63,64,65]. The specific problem type we illustrated in this section is an alternating current power flow problem.

The power flow equations are essential to analyzing the steady-state behavior of power systems by describing the relationship between bus voltages (magnitude and phase angles), currents, and power injections in a power system. The basic power flow equations are as follows:

$$\begin{array}{cc}\hfill P_k& =\sum _{j=1}^n\left(|V_k||V_j|\mathrm{Re}\left(Y_{kj}^{*}\right)\cos \left({\theta }_{kj}\right)+|V_k||V_j|\mathrm{Im}\left(Y_{kj}^{*}\right)\sin \left({\theta }_{kj}\right)\right)\hfill \\ \hfill Q_k& =\sum _{j=1}^n\left(|V_k||V_j|\mathrm{Re}\left(Y_{kj}^{*}\right)\sin \left({\theta }_{kj}\right)-|V_k||V_j|\mathrm{Im}\left(Y_{kj}^{*}\right)\cos \left({\theta }_{kj}\right)\right)\hfill \end{array}$$

where

• $P_k$: real power injection at bus k.
• $Q_k$: reactive power injection at bus k.
• $|V_k|$: voltage magnitude at bus k.
• ${\theta }_{kj}$: phase angle difference between bus k and bus j.
• $Y_{kj}$: admittance between bus k and bus j.

For a power flow problem with B buses and G generators, there are $2(B-1)-(G-1)$ unknowns representing voltage magnitudes, $|V_k|$, and phase angles, ${\theta }_k$, for load buses and voltage phase angles for generator buses. With the knowledge of the admittance matrix of the system that represents the nodal admittance of the buses, we can use the Newton–Raphson (N-R) method to solve power flow equation iteratively: after an initial guess for the voltages at all buses, in each N-R iteration, we solve

$$\begin{array}{c}\hfill \left[\begin{array}{cc}{\displaystyle \frac{\partial \Delta \overrightarrow{P}}{\partial \overrightarrow{\theta }}}& {\displaystyle \frac{\partial \Delta \overrightarrow{P}}{\partial |\overrightarrow{V}|}}\\ {\displaystyle \frac{\partial \Delta \overrightarrow{Q}}{\partial \overrightarrow{\theta }}}& {\displaystyle \frac{\partial \Delta \overrightarrow{Q}}{\partial |\overrightarrow{V}|}}\end{array}\right]\left[\begin{array}{c}\Delta \overrightarrow{\theta }\\ \Delta |\overrightarrow{V}|\end{array}\right]=-\left[\begin{array}{c}\Delta \overrightarrow{P}\\ \Delta \overrightarrow{Q}\end{array}\right]\end{array}$$

(4)

where $\Delta P_k$ and $\Delta Q_k$ are computed using the admittance matrix, nodal power balance equation, and mismatch equations with the data from the last iteration or initial guess. Then, $\overrightarrow{\theta }$ and $|\overrightarrow{V}|$ are updated by $\Delta \overrightarrow{\theta }$ and $\Delta |\overrightarrow{V}|$, respectively. The algorithm is considered converged when $\parallel \Delta \overrightarrow{P}\parallel$ and $\parallel \Delta \overrightarrow{Q}\parallel$ are smaller than a convergence tolerance.

It is worth noting that while HHL can solve Equation (4) for the normalized solution state $[\Delta {\overrightarrow{\theta }}^T\Delta |\overrightarrow{V}{{|}^T]}^T$ with limited accuracy, the un-normalized vector could have a smaller norm than the accuracy of HHL. Thus, the final accuracy of voltage magnitude and phase angles is much higher than the accuracy used in HHL. This situation is similar to iterative refinement in semi-definite optimization in [13].

5.1.1. Settings of the Numerical Experiments

The test case is the four buses and two generators problem in ([66], p. 377), coded in a MATLAB package called MATPOWER [67]. Based on the framework built in [68], we incorporate HHL circuits and quantum simulators into the solving process in MATPOWER. The linear systems of our interest are all $5\times 5$ systems but not Hermitian. So, the actual input system is first expanded to $8\times 8$ so the size of the RHS vector is the power of 2, and then it is enlarged to $16\times 16$ following Equation (1). So, we eventually use 4 qubits to encode the vector $\overrightarrow{b}$. This process is illustrated in Figure 3a.

The default value of $n_c$ set by [35] using Equation (3) is 6. To demonstrate how the accuracy of eigenvalues affects an iterative algorithm, we select $n_c$ from 4 to 7. With 4 clock qubits in QPE and an ancillary qubit required by the HHL algorithm, the number of qubits in each HHL circuit ranges from 9 to 12. The N-R method converges when

$$\begin{array}{c}\hfill {∥\left[\begin{array}{c}\Delta \overrightarrow{P}\\ \Delta \overrightarrow{Q}\end{array}\right]∥}_{\infty }<{10}^{-8}.\end{array}$$

However, because the linear system formed in an N-R iteration depends on the solution from the previous N-R iteration, the linear systems at Iteration j with different $n_c$ will differ. Our comparison focuses on the convergence speed and the final solution at the convergence instead of errors at each iteration across different $n_c$.

5.1.2. Performance Evaluations

The sparsity of all tested coefficient matrices is $84.375\%$ after the expansion, with condition numbers in the range of $[5.950,5.970]$. The minimums of the magnitude of eigenvalues are in the range of $[12.263,12.506]$, and the maximums are $[73.209,74.659]$. Figure 3b,c provide illustrative evidence of the use of a less precise linear solver in the iterative method like the N-R method. Although the N-R method with an HHL subroutine converges slower than a classical linear solver in MATLAB, all methods converge under the same criteria and obtain a similar solution. A trade-off between convergence speed and complexity of linear system solving exists in our experiments.

On the other hand, if we compare the values of normalized error $\parallel |x\rangle -{|x\rangle }_{HHL}{\parallel }_2$, when $n_c=4,5,6,7$, using more clock qubits indeed leads to lower error from the HHL algorithm itself. However, increasing $n_c$ does not imply less error on the solution vectors, ${\overrightarrow{x}}_{HHL}$, nor faster convergence by looking at the values of $\parallel \overrightarrow{x}-{\overrightarrow{x}}_{HHL}{\parallel }_2$ and ${[\Delta {\overrightarrow{P}}^T\Delta {\overrightarrow{Q}}^T]}^T$ in Figure 3. The HHL algorithm with $n_c=5$ gives the fastest convergence, which is smaller than the default value, 6, from Equation (3).

5.1.3. Gate Counts and Depths of HHL Circuits

Because the circuits from later iterations are in a similar resource demand, we only look at the circuits in the first iteration. The depths and gate counts of HHL circuits are the same across N-R iterations when $n_c$ is fixed. While HHL with $n_c=5,6,7$ gives similar convergence speed and accuracy, the required resources to run the circuits exponentially increase as $n_c$ increases based on

Table 5. Depths and gate counts of HHL circuits for power flow problems at Iteration 1.

${\mathit{n}}_{\mathit{d}}$	${\mathit{n}}_{\mathit{c}}$	Depth	Gates	2-Qubit Gates	Gates After Fusion	Reduction from Fusion
4	4	65,824	86,262	30,651	18,060	79.06%
4	5	135,986	178,180	63,315	37,283	79.08%
4	6	276,308	361,980	128,631	75,717	79.08%
4	7	556,950	729,534	259,247	152,570	79.09%

. On the other hand, although gate fusion employed in NWQSim does not mitigate these exponential trends, it maintains a constant proportional performance across various HHL circuits: a $79\%$ reduction in gate counts on all tested circuits regardless of the value of $n_c$.

5.1.4. Resource Estimation in a Fault-Tolerant Scenario 

Encoded by the surface code described in Section 4 along with a nearest-neighbor connectivity constraint, we estimate the runtime of HHL circuits by the Azure Quantum resource estimator and summarize the data in Figure 4. A strong and consistent linear correlation between the number of clock qubits in QPE, $n_c$, and the runtime in log base 10 is displayed across qubit parameter sets and error budgets. Every extra clock qubit brings ${10}^{0.322}\approx 2.099$ times longer runtime when the error budget is $0.1$ and ${10}^{0.375}\approx 2.371$ times longer when the error budget is $0.01$. This multiplier shows an increasing trend when the error budget decreases. Similar correlations are also demonstrated in Figure 5a,b when we further investigate how $n_c$ affects the number of logical cycles for the circuit and the number of T states. Generally, the exponential dependencies of runtime, number of logical cycles, and number of T states on $n_c$ match the relationship between the number of gates in HHL circuits and $n_c$. Note that the slopes of the fitted line in Figure 5a,b are not sensitive to error budgets, different from the behavior in Figure 4. Error budgets affect the constant multiplier of the growth of logical cycles and the number of T states more.

Table 6. Factors of interest for fault-tolerant HHL circuits in power flow problems.

Error Budget	${\mathit{n}}_{\mathit{c}}$	Physical Qubits After Layout	Logical Qubits Pre- and After Layout	Min. Logical Qubit Error Rate	Min. T State Error Rate
0.01	4	32,144	9 to 28	3.977 $\times {10}^{-10}$	9.831 $\times {10}^{-9}$
	5	28,380	10 to 30	1.797 $\times {10}^{-10}$	4.762 $\times {10}^{-9}$
	6	28,866	11 to 33	7.700 $\times {10}^{-11}$	2.236 $\times {10}^{-9}$
0.1	4	32,144	9 to 28	4.406 $\times {10}^{-9}$	1.098 $\times {10}^{-7}$
	5	32,340	10 to 30	1.990 $\times {10}^{-9}$	5.319 $\times {10}^{-8}$
	6	32,634	11 to 33	8.487 $\times {10}^{-10}$	2.483 $\times {10}^{-8}$

summarizes the other factors of our interest. Those factors have the same values in $(\mathrm{ns},{10}^{-4})$ and $(\mathrm{\mu }\mathrm{s},{10}^{-4})$ settings. Note that there is a dramatic fall in the number of physical qubits when the error budget is 0.01 and $n_c$ raises from 4 to 5. Combined with Figure 5c,d, this reduction comes from a large drop in the number of physical qubits spent on T factories, a dominant demand on physical qubits instead of the quantum algorithm itself. The circuit requires 15 T factories when the error budget is $0.01$ and $n_c=4$, but this number is reduced to 12 when $n_c=5$. Recall the definition of the number of T factories in Table 4, based on the fitted coefficients in Figure 4 and Figure 5; we can see while the increase in $n_c$ from 4 to 5 leads to ${10}^{0.322}$ times more T states, the runtime becomes ${10}^{0.375}$ times larger. Since T factory duration and T states per factory are kept constant, the faster-growing runtime reduces the number of T factories required, thus decreasing the overall number of physical qubits required. This phenomenon does not occur when the error budget is $0.1$ because the growth of runtime and T-state count are at the same speed.

5.2. Heat Transfer Problem in Climate Projection

Linear solvers are deeply embedded in linear or non-linear differential equation solving through numerical methods such as the Carleman linearization and the finite difference method [69]. Such methods discretize the domain of the problems into grids, and the dimension of the formed linear system scales as the size of discretization. The number of grid points scales polynomially with system size, while the demands for solving such differential equations (DEs) are ubiquitous in science and engineering. Due to the exponential speedup in problem dimension, the combination of quantum linear solvers and these numerical methods has become an attractive direction [69,70,71,72]. For example, accurate climate projection, one of the most scientifically challenging and socially urgent problems, is cursed by high dimension and could be revolutionized by quantum computing. In this section, we explore the application of a quantum linear system solver to the heat transfer equation that is important for atmospheric processes related to climate projection.

5.2.1. Settings of the Numerical Experiments

In this section, we examine the two-dimensional (2-D) heat diffusion equation in [73]

$$\begin{array}{c}\hfill {\displaystyle \frac{\partial T}{\partial t}}=D{\nabla }^{2}T+F\end{array}$$

(5)

where T represents the temperature at a given 2-D point and time, D is the heat transfer coefficient, and F is the forcing term consisting of arbitrary boundary and initial conditions. Equation (5) is a linear partial differential equation. We discretize Equation (5) in space and time into a system of ordinary differential equations using the finite difference method,

$$AT=F,$$

(6)

where A is the resulting coefficient matrix. Take the square lattices with a lateral size of three grid points and five grid points, and the resulting dimension of A is $9\times 9$ and $25\times 25$, respectively. Such configurations require 4 qubits and 5 qubits to represent the RHS vectors (F term in Equation (6)) in both linear systems, respectively. Let $A^{(heat,l)}$ be the coefficient matrix generated from l number of grid points; the entry values are

$$\begin{array}{c}\hfill A_{pq}^{(heat,l)}=\left\{\begin{array}{cc}1+4r,\hfill & p=q\hfill \\ -r\hfill & p=q\pm 1\mathrm{or}\mathrm{or}p=q\pm l\hfill \\ 0,\hfill & \mathrm{otherwise}\hfill \end{array}\right.\end{array}$$

where p and q denote the index of the entries of A, and r is $0.00016$ in the three-point case and $0.00064$ in the five-point case.

5.2.2. Performance and Resource Evaluations

The coefficient matrices are Hermitian by design, so we only need to expand the dimension to the nearest power of 2, i.e., 16 and 32. After dimension expansion, the coefficient matrices have sparsity $82.81\%$ and $88.28\%$, respectively. Both matrices have condition number 1, and all of their eigenvalues are around 1.

When $n_d=4$, gate counts in Table 5 and

Table 7. Depths and gate counts of HHL circuits for heat transfer problems.

Dim.	${\mathit{n}}_{\mathit{d}}$	${\mathit{n}}_{\mathit{c}}$	Depth	# of Gates	# of 2-Qubit Gates	# of Gates After Fusion	Reduction from Fusion
$9\times 9$	4	3	30,742	40,290	14,315	8445	79.04%
$9\times 9$	4	4	65,824	86,262	30,651	18,061	79.06%
$9\times 9$	4	5	135,986	178,180	63,315	37,284	79.08%
$9\times 9$	4	6	276,308	361,980	128,631	75,718	79.08%
$25\times 25$	5	3	133,966	175,253	62,546	37,147	78.80%
$25\times 25$	5	4	287,134	375,643	134,046	79,547	78.82%
$25\times 25$	5	5	593,948	777,069	277,230	164,338	78.85%

have almost the same numbers of circuit depths and gate counts. However, if we compare across different $n_d$ in Table 7, significant increases appear in depths and all gate counts. This situation reflects one of Aaronson’s concerns in [74] about the efficiency and the cost of data reading in quantum linear solvers. Furthermore, similar to the scenario in Section 5.1, the incremental of $n_c$, despite being very costly, has a limited contribution towards reducing errors, as shown in Figure 6.

5.2.3. Resource Estimation in a Fault-Tolerant Scenario

Most of the observations from Figure 7 and Figure 8 and

Table 8. Factors of interest for fault-tolerant HHL circuits in heat transfer problems.

Error Budget	$({\mathit{n}}_{\mathit{d}},{\mathit{n}}_{\mathit{c}})$	Physical Qubits After Layout	Logical Qubits Pre- and After Layout	Min. Logical Qubit Error Rate	Min. T State Error Rate
0.01	(4, 3)	31,850	8 to 25	1.01 $\times {10}^{-9}$	2.22 $\times {10}^{-8}$
	(4, 4)	32,144	9 to 28	3.97 $\times {10}^{-10}$	9.81 $\times {10}^{-9}$
	(4, 5)	28,380	10 to 30	1.80 $\times {10}^{-10}$	4.77 $\times {10}^{-9}$
	(4, 6)	28,866	11 to 33	7.69 $\times {10}^{-11}$	2.23 $\times {10}^{-9}$
	(5, 3)	28,056	9 to 28	2.05 $\times {10}^{-10}$	5.11 $\times {10}^{-9}$
	(5, 4)	28,380	10 to 30	8.53 $\times {10}^{-11}$	2.27 $\times {10}^{-9}$
0.1	(4, 3)	13450	8 to 25	1.12 $\times {10}^{-8}$	2.50 $\times {10}^{-7}$
	(4, 4)	32,144	9 to 28	4.40 $\times {10}^{-9}$	1.10 $\times {10}^{-7}$
	(4, 5)	32,340	10 to 30	2.00 $\times {10}^{-9}$	5.33 $\times {10}^{-8}$
	(4, 6)	32,634	11 to 33	8.47 $\times {10}^{-10}$	2.48 $\times {10}^{-8}$
	(5, 3)	32,144	9 to 28	2.27 $\times {10}^{-9}$	5.70 $\times {10}^{-8}$
	(5, 4)	32,340	10 to 30	9.39 $\times {10}^{-10}$	2.52 $\times {10}^{-8}$

for both problem sizes are analogous to the findings in Section 5.1.4, including the numerical values of the fitted-line coefficients related to runtime, logical cycles, and the number of T states. The significant influence brought by deeper data-loading modules for the five-point problem is parallel shifts on longer runtime, more logical cycles, more T states, and more strict requirements on the logical qubit error rate and T state error rate. More data-loading qubits do not affect the growth speed of the logical cycle and the number of T states. Due to the limitation of computational time in Azure Quantum cloud service, we cannot collect more data points to understand this correlation better. However, from a theoretical perspective, this is expected because the QPE costs of HHL circuits are the same with the same $n_c$ in the power flow and heat transfer problems.

6. Discussion

This paper evaluates and analyzes the performance and resources required for the HHL algorithm in various scientific and engineering problems. There are still multiple points we need to address in future work. The foremost limitation in this work is the data-loading module in the HHL circuit generation. While the data-loading algorithm in [55] can encode an arbitrary vector into a quantum circuit, the circuit depth of this module is exponential in the number of qubits. Thus, this first part of the circuit severely damages the potential quantum speedup from HHL. We mitigate this drawback by comparing the outcomes from problems of different sizes to isolate the influence of the data-loading module. An important future direction is incorporating an efficient data-loading scheme into our analysis framework, like block-encoding in [8]. A different data-loading method could have a different accuracy, so it is necessary to investigate how data-loading accuracy and condition number of coefficient matrices collectively affect the solution accuracy. This future direction illustrates the second drawback of this study. That is, our tested coefficient matrices are all well-conditioned. Because our experiments do not utilize randomly generated test cases, we have less control over the matrix properties, including condition number and sparsity. A potential source of ill-conditioned test cases is the methods that naturally have ill-conditioned matrices, such as the Newton systems produced by the interior-point method in optimization problems [13]. Thus, to solve those systems, iterative refinement with the HHL algorithm [9] and a variant of the HHL algorithm in [15], accompanied by the sparse approximate inverse preconditioner, is in our outlook. Limited by the single-job running time in the Azure Quantum cloud server, we cannot process large HHL circuits, mainly limited by the number of gates. This restricts the number of clock qubits in the QPE and the number of data points in each plot in Section 5. This is why we only discuss the correlations whose coefficients of determination are almost 1. In future studies, we will dismantle the whole HHL circuit into different modules and evaluate the resource cost separately.

Some additional research can be conducted to further enhance our understanding of the application of quantum algorithms in scientific problems. An important direction is understanding the implication of various noise models on the HHL algorithm. We plan to conduct those experiments with the high-precision noise simulator in [75]. We can also include the quantum algorithms that address similar scientific applications into our resource analysis framework, such as quantum differential equation solvers in [76,77] and quantum optimizers in [78,79].

7. Conclusions

In this paper, we investigate the practical applications and scalability of the HHL algorithm in solving quantum linear systems associated with scientific problems like power grids and heat transfer problems. Through the NWQSim package on high-performance computing platforms, we highlight the benefits of the utilization of low-accuracy QPE in HHL for both iterative and non-iterative methods in practice: low-accuracy QPE can exponentially reduce the gate counts and circuit depth in an HHL circuit, while keeping the same solution accuracy in iterative methods like the Newton–Raphson method and maintaining a similar level of accuracy in a non-iterative method like the finite difference method.

Furthermore, with the Azure Quantum resource estimator, we evaluate the resource requirements of HHL circuits in our experiments under two settings that simulate superconducting and trapped-ion qubits. The correlations between QEC-related criteria and the input HHL circuits have been thoroughly studied. The runtime, number of logical cycles, and number of T states have exponential dependencies on the number of clock qubits in QPE. However, this relation is not necessarily inherited by the number of physical qubits demanded. In our experiments, we find that even as $n_c$ increases and the error budget reduces, it is possible that T factory demand also decreases. More specifically, if the runtime growth is faster than the required amount of T states, the circuit needs fewer T factories and thus fewer physical qubits to prepare T factories. Since the growth of runtime is sensitive to the error budget, it is possible to reduce the physical qubit requirement if a low error budget is achievable on early fault-tolerant quantum devices.

Our study provides pivotal insights into the operational requirements of quantum linear system algorithms, paving the way for further empirical studies. We propose future research on the applications of quantum linear system solvers and iterative refinement on high-fidelity quantum computers for small-scale experiments. For large-scale experiments, we suggest using noise-modeled simulators on high-performance platforms. In the context of QEC and early fault-tolerant quantum computing, we believe it is crucial to focus on controlling the resource cost of T factories by considering the runtime and error budget. These research directions hold promise for bridging the gap between theoretical potential and practical usability in quantum computing. All the code in this research will be hosted in a public repository (https://github.com/pnnl/nwqlib, accessed on 4 August 2025).