Solving Multidimensional Partial Differential Equations Using Efficient Quantum Circuits

Abstract

Quantum computing has the potential to solve certain compute-intensive problems faster than classical computing by leveraging the quantum mechanical properties of superposition and entanglement. This capability can be particularly useful for solving Partial Differential Equations (PDEs), which are challenging to solve even for High-Performance Computing (HPC) systems, especially for multidimensional PDEs. This led researchers to investigate the usage of Quantum-Centric High-Performance Computing (QC-HPC) to solve multidimensional PDEs for various applications. However, the current quantum computing-based PDE-solvers, especially those based on Variational Quantum Algorithms (VQAs) suffer from limitations, such as low accuracy, long execution times, and limited scalability. In this work, we propose an innovative algorithm to solve multidimensional PDEs with two variants. The first variant uses Finite Difference Method (FDM), Classical-to-Quantum (C2Q) encoding, and numerical instantiation, whereas the second variant utilizes FDM, C2Q encoding, and Column-by-Column Decomposition (CCD). We evaluated the proposed algorithm using the Poisson equation as a case study and validated it through experiments conducted on noise-free and noisy simulators, as well as hardware emulators and real quantum hardware from IBM. Our results show higher accuracy, improved scalability, and faster execution times in comparison to variational-based PDE-solvers, demonstrating the advantage of our approach for solving multidimensional PDEs.

1. Introduction

Partial Differential Equations (PDEs) can model complex systems across various fields, such as finance, physics, and mathematics [1,2]. Although there are advanced classical algorithms for solving PDEs [3] due to the curse of dimensionality, solving them is highly computationally intensive, especially for multidimensional PDEs [4]. As classical semiconductor technology is reaching its limits, there is a need to find alternative technologies for performing compute-intensive tasks [5]. In order to reduce computational time, researchers are exploring various technologies for solving PDEs [6,7,8]. Owing to its great potential to revolutionize computational speed, quantum computing in the last decade has emerged as a promising technology to solve even highly computationally intensive practical problems [9,10]. This is because it supports inherent parallelism due to the quantum mechanical properties of superposition and entanglement [11].

Another key advantage of quantum computing is its ability to handle large datasets using only a logarithmic number of quantum bits (qubits) relative to the data size. Because of these benefits, solving PDEs using quantum computers relevant to various practical applications is becoming an active area of research [12]. Recently, researchers have also started exploring the usage of Quantum-Centric High-Performance Computing (QC-HPC) to solve nonlinear partial differential equations [13].

Most of the currently used quantum computing-based PDE-solvers are either based on the Harrow–Hassidim–Lloyd (HHL) algorithm or on Variational Quantum Algorithms (VQAs) [6]. The PDEs can be solved using the HHL algorithm [14] after discretizing it into linear equations using the Finite Difference Method (FDM) [15]. Although the HHL algorithm can provide exponential speedup over classical methods for solving linear systems with sparse coefficient matrices, it requires error-corrected systems with a large number of qubits [16]. Because of the limitations of error-correction in Noisy-Intermediate Scale Quantum (NISQ) devices, researchers are currently investigating alternative techniques such as VQAs to solve PDEs [17,18,19,20]. The VQAs used to solve PDEs are either based on Variational Quantum Eigensolver (VQE) or Variational Quantum Linear Solver (VQLS) [17,18,19,20]. However, the VQA-based PDE solvers suffer from high execution time, limited scalability, and very low accuracy.

In this work, we propose a time-efficient, scalable, and accurate quantum algorithm for solving multidimensional PDEs on Quantum-Centric High-Performance Computing (QC-HPC) systems. Our algorithm is categorized into two variants, i.e., Variant 1 and Variant 2. Variant 1 uses the Finite Difference Method (FDM), Classical-to-Quantum (C2Q) data encoding [21], and numerical instantiation [22], whereas Variant 2 uses FDM, C2Q encoding, and Column-by-Column Decomposition (CCD) [23,24]. For our experiments, we have used multidimensional Poisson equations as a case study. Our experimental results showcase favorable results in terms of accuracy, scalability, and execution time in comparison to VQA-based solvers on noise-free and noisy simulators, hardware emulators, and real quantum hardware from IBM [24].

The remaining sections of this paper are structured as follows: Section 2 provides background information, Section 3 highlights related work, and Section 4 discusses the proposed methodology in detail. The experimental results are presented in Section 5. Section 6 provides a discussion about the experimental outcomes. Finally, Section 7 concludes the paper with potential future work.

2. Background

In this section, we discuss the background information related to the data encoding techniques of Classical-to-Quantum (C2Q) encoding, numerical instantiation, and Column-by-Column Decomposition (CCD) used in our proposed work. The basic and fundamental information on quantum bits (qubits), quantum states, and quantum gates necessary to understand our proposed algorithm, can be found in Appendix A, while details on classical preprocessing steps are provided in Appendix B.

2.1. Classical-to-Quantum Encoding (C2Q)

In our proposed algorithm, we need to generate a quantum circuit for a normalized vector $\overrightarrow{b}$, see (A3). The details of the normalization procedure are discussed in Section 4.1. To generate the quantum circuit for a normalized vector $\overrightarrow{b}$, we have leveraged the most depth-optimized version of amplitude encoding, called Classical-to-Quantum (C2Q) encoding [21]. This technique uses 50% fewer quantum gates than the next best alternative [25]. Because it can generate shallow quantum circuits, this technique is suitable for NISQ devices, where execution must be completed within the decoherence time. C2Q converts data from the classical domain to the quantum domain with quantum coefficients ranging from $c_0$ to $c_{N-1}$ as shown in Figure 1 and (1). Here, $N=2^n$ and n is the number of qubits.

$$\begin{array}{cc}\hfill |\psi \rangle & =U^{C2Q}·{|\psi }_0\rangle =U^{C2Q}·{|0\rangle }^{\otimes n}\hfill \\ \hfill & =\sum _{i=0}^{N-1}{c}_i|i\rangle ,\mathrm{where}\sum _{i=0}^{N-1}{\left|c_i\right|}^2=1\hfill \end{array}$$

(1)

2.2. Numerical Instantiation

Numerical instantiation is a technique for generating quantum circuits for target unitaries. This method is particularly useful when a unitary operation cannot be easily decomposed into standard gate sets. In general, synthesis algorithms based on numerical instantiation decompose quantum circuits into a template Parameterized Quantum Circuit (PQC) and then use numerical optimization techniques for tuning the parameters of the PQC. Some state-of-the-art compilation tools, such as IBM Qiskit [26], Tket [27], and Google Cirq [28] provide support for this method of circuit instantiation. We have used the Berkeley Quantum Synthesis toolKit (BQSKit) [22] in the unitary matrix U conversion step of the proposed algorithm, see (A4). The BQSKit can go beyond a fixed template by also searching over or incrementally modifying the circuit topology along with the parameters. This technique follows a workflow that generates a depth-optimized circuit for a target unitary, as shown in Figure 2. It first breaks the unitary matrix into sub-unitaries using hierarchical decomposition methods such as KAK decomposition [29] and Cosine–Sine Decomposition (CSD) [30]. Hierarchical decomposition is followed by an Intermediate Representation (IR), in which these sub-unitaries and their dependencies are stored in a structural format such as a Directed Acyclic Graph (DAG). The IR is then used for the creation of PQCs for each sub-unitary, which are subsequently numerically optimized and merged. If the system size is large, the circuit is partitioned for parallel optimization. These sub-blocks are optimized using a numerical optimizer and then merged into a complete circuit. After this, the parameterized gates are mapped to hardware-native gates in the gate set rebasing step. This is followed by circuit optimizations, and finally, a quantum circuit is synthesized. This flexibility allows numerical instantiation to discover more efficient circuit layouts [31]. The advantage of using this tool lies in reducing the number of resource-intensive components such as CNOT gates [32] and thus reducing the total depth of the circuit. The reduced depth is also helpful in reducing the accumulation of errors due to gate imperfection. These optimization steps help BQSKit generate the depth-optimized quantum circuits necessary for the efficient execution on NISQ devices within the coherence time [33].

2.3. Column-by-Column Decomposition (CCD)

Column-by-Column Decomposition (CCD) [23,24] is a method for converting arbitrary isometries into sequences of single-qubit and controlled-NOT (CNOT) gates [23]. This technique constructs a quantum circuit for a unitary matrix by processing one column at a time and preparing the corresponding quantum state from a basis state. Qiskit [26] implements the CCD technique using the QuantumCircuit.unitary() ibmQuantumCircuit2024 function which generates a quantum circuit from an arbitrary unitary matrix by factorizing the unitary into simpler components that can be implemented using standard gate sets. The CCD technique generates quantum circuits faster than the numerical instantiation technique with a higher accuracy. Additionally, this approach offers higher scalability, especially on noise-free and noisy simulators. Because of its high accuracy, fast execution, and good scalability, CCD proves to be a highly useful approach for quantum circuit synthesis. Although this technique generates quantum circuits rapidly compared to numerical instantiation, sometimes the depth of the generated circuits is significantly high, which makes them difficult to execute on the current quantum hardware within limited coherence times. However, the ongoing research in data encoding strategies, efficient compilers, and robust quantum hardware is expected to help mitigate this challenge in the future [33].

2.4. Decoherence Time

In quantum computing, decoherence time describes how long a qubit can maintain its quantum state before environmental noise disrupts its state of superposition [34]. There are two key timing parameters associated with a qubit: T1 time and T2 time [11]. Here, T1 is the relaxation time over which an excited qubit returns to its ground state, and T2 is the dephasing time that determines how long the qubit preserves its phase information [35]. In practice, T2 is often considered the decoherence time because losing the phase typically occurs faster than relaxation. In quantum computing, when the circuit’s execution time exceeds the qubit’s decoherence time, the resulting measurements are prone to significant noise and thus reduced accuracy. Since individual qubits have different decoherence times, researchers frequently use the median T2 value as an overall device decoherence time. In our experiments, we have used a quantum emulator (FakeSherbrooke) along with real quantum hardware (ibm_sherbrooke). The reason for using FakeSherbrooke is that it closely replicates the characteristics of real quantum hardware ibm_sherbrooke and is freely available. This allows researchers to rapidly test their algorithm and assess the expected performance on real hardware without the lengthy queue delays associated with real quantum devices. The T2 times of the individual qubits for FakeSherbrooke and ibm_sherbrooke are shown in Figure 3, where the red line indicates their median decoherence time.

3. Related Work

In our review of the existing work related to solving PDEs using quantum computing, the existing techniques can be broadly classified as those based on HHL [14] and VQA [36]. The HHL algorithm [14], designed to solve linear systems, offers exponential speedup for sparse coefficient matrices and can be applied to PDEs after discretization using FDM [15]. An improved version of the HHL algorithm [37] improves efficiency by reducing computation time while maintaining accuracy. However, both methods require fault-tolerant quantum operations, making them unsuitable for NISQ devices. To overcome these limitations, VQA-based approaches have been explored. The authors in [17] develop a minimum potential energy-based cost function to solve the Poisson equation, similar to VQE-based PDE solvers. The authors in [18] use VQLS with discrete finite element methods, achieving scalability up to 10 qubits, while the authors in [19] apply VQLS to the Poisson equation, resulting in good performance on quantum simulations but poor performance on real quantum hardware. Furthermore, the authors in [20] propose a VQA approach that minimizes quantum measurements and resource usage. Our study of PDE solvers using VQA shows that existing techniques for solving PDEs have low accuracy and long execution times compared to analytical solutions, as well as limited scalability with qubits. The results of our proposed PDE solver algorithm, which utilizes FDM, C2Q encoding, and numerical instantiation in Variant 1, and FDM, C2Q encoding, and CCD in Variant 2, outperform VQA-based PDE solvers in accuracy, scalability, and execution time, and generates favorable results on noise-free and noisy simulators, as well as on hardware emulators and real quantum hardware.

4. Materials and Methods

In this section, we present the materials and methods associated with our proposed algorithm to solve Partial Differential Equations (PDEs). The proposed work leverages the Finite Discrete Method (FDM) for the discretization of PDE. After discretization, Variant 1 of the proposed algorithm uses Classical-to-Quantum (C2Q) encoding [21] and numerical instantiation [22], while Variant 2 employs C2Q encoding with Column-by-Column Decomposition (CCD) [23,24]. Here, we have used the multidimensional Poisson equation as a case study. For preprocessing steps, we have employed polar decomposition and Singular Value Decomposition (SVD). For detailed information regarding these preprocessing steps, refer to the Appendix B. Some of the major contributions of our work are as follows:

• Proposed an accurate, scalable, and time-efficient algorithm for solving multidimensional Partial Differential Equations (PDEs).
• Evaluated the proposed algorithm on noise-free and noisy simulators, as well as on hardware emulators and real quantum hardware from IBM-Qiskit.
• Compared the proposed work with a variational algorithms-based PDE solver in terms of accuracy, scalability, and total execution time, using the Poisson equation as a case study.
• Presented the theoretical execution time comparison of the circuits generated by our algorithm for hardware emulator and real quantum hardware with the decoherence times of these systems.

4.1. Proposed Methodology: Scalable and Accurate PDE Solver Algorithm

The high-level overview of the proposed PDE solver algorithm for Variant 1 and Variant 2 is shown in Figure 4a,b.

By applying FDM, a partial differential equation (PDE) can be converted into a system of linear equations, see (2):

$$A\overrightarrow{u}=\overrightarrow{b}$$

(2)

As stated earlier, our proposed algorithm needs a preprocessing step of polar decomposition and SVD. We apply polar decomposition to the matrix A, see (2) to factor it into a unitary matrix U and a positive semi-definite symmetric matrix P, see (3).

$$\left(PU\right)\overrightarrow{u}=\overrightarrow{b}$$

(3)

By rearranging (3), we can obtain (4), which can be further rearranged into (5). We then divide both sides of (5) with the normalization factor $\left|\right|P^{-1}\overrightarrow{b}\left|\right|$ to obtain (6).

$$U\overrightarrow{u}=P^{-1}\overrightarrow{b}$$

(4)

$$\overrightarrow{u}=U^{†}{P}^{-1}\overrightarrow{b}$$

(5)

$${\displaystyle \frac{\overrightarrow{u}}{∥P^{-1}\overrightarrow{b}∥}}=U^{†}·\left({\displaystyle \frac{P^{-1}\overrightarrow{b}}{∥P^{-1}\overrightarrow{b}∥}}\right)$$

(6)

We can rewrite (6) in the form shown in (7), where $|{\psi }_{in}\rangle$ is the input quantum state encoded using C2Q encoding [21], and $|{\psi }_{out}\rangle$ is the corresponding output state after applying $U^{†}$ to $|{\psi }_{in}\rangle$. Converting $U^{†}$ into a quantum circuit is accomplished using the approach of numerical instantiation [22] in Variant 1, and using CCD [23,24] in Variant 2.

$$\begin{array}{c}\hfill |{\psi }_{out}\rangle =U^{†}·|{\psi }_{in}\rangle ,\mathrm{where}|{\psi }_{out}\rangle ={\displaystyle \frac{\overrightarrow{u}}{∥P^{-1}\overrightarrow{b}∥}},\mathrm{and}|{\psi }_{in}\rangle ={\displaystyle \frac{P^{-1}\overrightarrow{b}}{∥P^{-1}\overrightarrow{b}∥}}\end{array}$$

(7)

To solve (7), we require $U^{†}$ and $P^{-1}$. Both can be derived by applying the Singular Value Decomposition (SVD) [38] to A, as specified in (8). In this decomposition, $\Sigma$ is a diagonal matrix, and W and V are unitary matrices.

$$\begin{array}{cc}\hfill A=PU=W\Sigma V^{†},\mathrm{where} P=W\Sigma W^{†},\mathrm{and} U& =W{V}^{†}\hfill \end{array}$$

(8)

The value of $P^{-1}$ and $U^{†}$ can be obtained using (9) and (10), respectively.

$$P^{-1}=W{\Sigma }^{-1}{W}^{†}$$

(9)

$$U^{†}=V{W}^{†}$$

(10)

The value of $|{\psi }_{in}\rangle$, as shown in (11), can be obtained by using (9) in (7).

$$|{\psi }_{in}\rangle ={\displaystyle \frac{W{\Sigma }^{-1}{W}^{†}\overrightarrow{b}}{∥W{\Sigma }^{-1}{W}^{†}\overrightarrow{b}∥}}$$

(11)

The quantum circuit generated using the numerical instantiation technique [22] in Variant 1 and using CCD [23,24] in Variant 2 circuit receives $|{\psi }_{in}\rangle$ as its input state and generates $|{\psi }_{out}\rangle$ as an output state, see (7). By measuring $|{\psi }_{out}\rangle$, we recover the classical vector ${\overrightarrow{\psi }}_{out}$ as given in (12) [39]. The unknown vector $\overrightarrow{u}$ can then finally be obtained using (13) [39].

$${\overrightarrow{\psi }}_{out}\approx U^{†}|{\psi }_{in}\rangle$$

(12)

$$\overrightarrow{u}={\overrightarrow{\psi }}_{out}∥W{\Sigma }^{-1}{W}^{†}\overrightarrow{b}∥$$

(13)

4.2. Multidimensional Poisson Equation

A p-dimensional Poisson equation can be formulated as shown in (14), where ${\nabla }^2$ is the Laplacian operator, u is the unknown function to be determined, and f is a known source function.

$${\nabla }^{2}u=\sum _{i=1}^p{\displaystyle \frac{{\partial }^{2}u}{\partial s_i^2}}=f\left(s_1,s_2,\dots s_p\right)$$

(14)

4.2.1. 1D Poisson Equation

A 1D-Poisson equation is defined as shown in (15).

$${\displaystyle \frac{{\partial }^{2}u\left(x\right)}{\partial x^2}}=f\left(x\right)$$

(15)

Here, $u\left(x\right)$ is the unknown function, and $f\left(x\right)$ acts as a source function. Using the FDM technique, the 1D Poisson equation, see (15), can be converted into a discretized difference equation, as shown in (16). Figure 5 shows the FDM grid for solving the 1D Poisson equation. Here, ${\Delta }_x$ is the grid spacing in the x-direction, $X_{N_x}$ and $X_{-1}$ are the boundary locations, and $N_x$ denotes the total number of points lying between the boundaries. By substituting the indices of the grid points, i.e., $0\le x_i<N_x$, and the boundary values (BVs) in (16), it can be converted into the matrix form $A\overrightarrow{u}=\overrightarrow{b}$. As shown in Figure 5, the values at the boundaries can be represented as $u_{X_{N_x}}$ and $u_{X_{-1}}$.

$${\displaystyle \frac{u_{x_i-1}-2u_{x_i}+u_{x_i+1}}{{\Delta }_x^2}}=f_{x_i},\mathrm{where}{\Delta }_x={\displaystyle \frac{X_{max}-X_{min}}{N_x-1}}$$

(16)

4.2.2. 2D Poisson Equation

A 2D Poisson equation can be formulated as shown in (17).

$$\left({\displaystyle \frac{{\partial }^2}{\partial x^2}}+{\displaystyle \frac{{\partial }^2}{\partial y^2}}\right)u(x,y)=f(x,y)$$

(17)

Using the FDM technique, the 2D Poisson equation, see (17), is transformed into a discretized difference equation, as illustrated in (18). Figure 6 shows the FDM grid for solving the 2D Poisson equation. Here, ${\Delta }_x$ is the grid spacing along the x-dimension and ${\Delta }_y$ is the grid spacing along the y-dimension. The step size for the overall 2D grid is $\Delta =min({\Delta }_x,{\Delta }_y)$. The expression in (18) can be converted to matrix form $A\overrightarrow{u}=\overrightarrow{b}$ by using the grid point indices $x_i$ and $y_i$, where $0\le x_i<N_x$ and $0\le y_i<N_y$.

$$u_{x_i-1,y_i}-2u_{x_i,y_i}+u_{x_i+1,y_i}+u_{x_i,y_i-1}-2u_{x_i,y_i}+u_{x_i,y_i+1}=f_{x_i,y_i}{\Delta }^2$$

(18)

$${\Delta }_x={\displaystyle \frac{X_{max}-X_{min}}{N_x-1}}$$

(19)

$${\Delta }_y={\displaystyle \frac{Y_{max}-Y_{min}}{N_y-1}}$$

(20)

4.2.3. 3D Poisson Equation

A 3D Poisson equation is defined as shown in (21). Figure 7 shows the FDM grid with spacing ${\Delta }_x$, ${\Delta }_y$, and ${\Delta }_z$.

$$\begin{array}{cc}\hfill & \left({\displaystyle \frac{{\partial }^2}{\partial x^2}}+{\displaystyle \frac{{\partial }^2}{\partial y^2}}+{\displaystyle \frac{{\partial }^2}{\partial z^2}}\right)u(x,y,z)=f(x,y,z)\hfill \end{array}$$

(21)

The step size along x-, y-, and z-dimensions are shown in (22). After applying second-order finite approximation and considering $\Delta =min({\Delta }_x,{\Delta }_y,{\Delta }_z)$, (21) can be discretized into (23). The expression in (23) can be converted into the matrix form $A\overrightarrow{u}=\overrightarrow{b}$ by using the grid point indices $x_i$, $y_i$, and $z_i$, where $0\le x_i<N_x$, $0\le y_i<N_y$, and $0\le z_i<N_z$.

$$\begin{array}{c}\hfill {\Delta }_x={\displaystyle \frac{X_{max}-X_{min}}{N_x-1}},{\Delta }_y={\displaystyle \frac{Y_{max}-Y_{min}}{N_y-1}},{\Delta }_z={\displaystyle \frac{Z_{max}-Z_{min}}{N_z-1}}\end{array}$$

(22)

$$\begin{array}{cc}\hfill & u_{x_i-1,y_i,z_i}-2·u_{x_i,y_i,z_i}+u_{x_i+1,y_i,z_i}+u_{x_i,y_i-1,x_i}-2·u_{x_i,y_i,z_i}+u_{x_i,y_i+1,z_i}+\hfill \\ \hfill & u_{x_i,y_i,z_i-1}-2·u_{x_i,y_i,z_i}+u_{x_i,y_i,z_i+1}=f_{i,j,k}·{\Delta }^2\hfill \end{array}$$

(23)

4.2.4. 4D Poisson Equation

A 4D Poisson equation can be written as shown in (24). The four dimensions considered in (24) are spatial dimensions x, y, and z, along with the temporal dimension t.

$$\begin{array}{cc}\hfill & {\displaystyle \frac{{\partial }^{2}u(x,y,z,t)}{\partial x^2}}+{\displaystyle \frac{{\partial }^{2}u(x,y,z,t)}{\partial y^2}}+{\displaystyle \frac{{\partial }^{2}u(x,y,z,t)}{\partial z^2}}+\hfill \\ \hfill & {\displaystyle \frac{{\partial }^{2}u(x,y,z,t)}{\partial t^2}}=f(x,y,z,t)\hfill \\ \end{array}$$

(24)

The step size along x-dimension, y-dimension, and z-dimension are shown in (25).

$$\begin{array}{cc}\hfill & {\Delta }_x={\displaystyle \frac{X_{max}-X_{min}}{N_x-1}}={\displaystyle \frac{X_{diff}}{N_x-1}},\hfill \\ \hfill & {\Delta }_y={\displaystyle \frac{Y_{max}-Y_{min}}{N_y-1}}={\displaystyle \frac{Y_{diff}}{N_y-1}},\hfill \\ \hfill & {\Delta }_z={\displaystyle \frac{Z_{max}-Z_{min}}{N_z-1}}={\displaystyle \frac{Z_{diff}}{N_z-1}},\hfill \\ \hfill & {\Delta }_t={\displaystyle \frac{t_{max}-t_{min}}{N_t-1}}={\displaystyle \frac{t_{diff}}{N_t-1}}\hfill \end{array}$$

(25)

After applying second-order finite approximation and considering $\Delta =min({\Delta }_x,{\Delta }_y,{\Delta }_z,{\Delta }_t)$, (24) can be discretized into (26). By rearranging the terms in (26), it can be further reduced to (27). The expression in (27) can be converted into the matrix form $A\overrightarrow{u}=\overrightarrow{b}$, using the grid point indices $x_i$, $y_i$, $z_i$, and $t_i$, where $0\le x_i<N_x$, $0\le y_i<N_y$, $0\le z_i<N_z$, and $0\le t_i<N_t$.

$$\begin{array}{cc}\hfill & \left({\displaystyle \frac{u_{t_i,z_i{y}_i,x_i+1}-2u_{t_i,z_i{y}_i,x_i}+u_{t_i,z_i{y}_i,x_i+1}}{{\Delta }_x^2}}\right)+\left({\displaystyle \frac{u_{t_i,z_i,y_i+1,x_i}-2u_{t_i,z_i,y_i,x_i}+u_{t_i,z_i,y_i+1,x_i}}{{\Delta }_y^2}}\right)+\hfill \\ \hfill & \left({\displaystyle \frac{u_{t_i,z_i+1,y_i,x_i}-2u_{t_i,z_i,y_i,x_i}+u_{t_i,z_i+1,y_i,x_i}}{{\Delta }_z^2}}\right)+\left({\displaystyle \frac{u_{t_i+1,z_i{y}_i,x_i}-2u_{t_i,z_i{y}_i,x_i}+u_{t_i+1,z_i{y}_i,x_i}}{{\Delta }_t^2}}\right)=f_{ti,z_i,y_i,x_i}\hfill \end{array}$$

(26)

$$\begin{array}{cc}\hfill & -8u_{t_i,z_i{y}_i,x_i}+u_{t_i,z_i,y_i,x_i+1}+u_{t_i,z_i,y_i,x_i-1}+\hfill \\ \hfill & u_{t_i,z_i,y_i+1,x_i}+u_{t_i,z_i,y_i-1,x_i}+u_{t_i,z_i+1,y_i,x_i}+u_{t_i,z_i-1,y_i,x_i}+\hfill \\ \hfill & u_{t_i-1,z_i,y_i,x_i}+u_{t_i+1,z_i,y_i-1,x_i}=f_{ti,z_i,y_i,x_i}\hfill \end{array}$$

(27)

The matrix A and the vector $\overrightarrow{b}$ can be determined for any number of dimensions up to four using the Algorithm 1.

Algorithm 1 Generate matrix $\mathbf{A}$ and vector $\mathbf{b}$ for upto 4D Poisson equation

1: Input:   2:  ${\displaystyle X_{diff},Y_{diff},Z_{diff},t_{diff}}$           ▹ Domain lengths in each dimension   3:  ${\displaystyle N_x^{\prime },N_y^{\prime },N_z^{\prime },N_t^{\prime }}$           ▹ Initial number of points in each dimension   4:   Qubits used for each dimension   5:  ${\displaystyle n_{x\_qubits}\leftarrow \lceil {log}_2{N}_x^{\prime }\rceil }$   6:  ${\displaystyle n_{y\_qubits}\leftarrow \lceil {log}_2{N}_y^{\prime }\rceil }$   7:  ${\displaystyle n_{z\_qubits}\leftarrow \lceil {log}_2{N}_z^{\prime }\rceil }$   8:  ${\displaystyle n_{t\_qubits}\leftarrow \lceil {log}_2{N}_t^{\prime }\rceil }$   9:   Adjust grid sizes for quantum-based approach (if needed). 10:  ${\displaystyle N_x\leftarrow 2^{n_{x\_qubits}}}$ 11:  ${\displaystyle N_y\leftarrow 2^{n_{y\_qubits}}}$ 12:  ${\displaystyle N_z\leftarrow 2^{n_{z\_qubits}}}$ 13:  ${\displaystyle N_t\leftarrow 2^{n_{t\_qubits}}}$ 14:  ${\displaystyle n_{total\_qubits}\leftarrow \sum \left(n_{x\_qubits},n_{y\_qubits},n_{z\_qubits},n_{t\_qubits}\right)}$ 15:  ${\displaystyle u_{x_{-1}},u_{y_{-1}},u_{z_{-1}},u_{t_{-1}}}$            ▹ Boundary values (lower ends) 16:  ${\displaystyle u_{N_x},u_{N_y},u_{N_z},u_{N_t}}$             ▹ Boundary values (upper ends) 17:   Define coefficients ${\lambda }_x,{\lambda }_y,{\lambda }_z,{\lambda }_t$ 18: ${\displaystyle {\lambda }_x\leftarrow \left\{\begin{array}{c}1 \mathrm{if}{N}_x>1\hfill \\ 0 \mathrm{otherwise}\end{array}\right.}$ 19:   20: ${\displaystyle {\lambda }_y\leftarrow \left\{\begin{array}{c}1 \mathrm{if}{N}_y>1\hfill \\ 0 \mathrm{otherwise}\end{array}\right.}$ 21:   22: ${\displaystyle {\lambda }_z\leftarrow \left\{\begin{array}{c}1 \mathrm{if}{N}_z>1\hfill \\ 0 \mathrm{otherwise}\end{array}\right.}$ 23:   24: ${\displaystyle {\lambda }_t\leftarrow \left\{\begin{array}{c}1 \mathrm{if}{N}_t>1\hfill \\ 0 \mathrm{otherwise}\end{array}\right.}$ 25:   Compute physical step sizes in each dimension 26: ${\displaystyle {\Delta }_x\leftarrow \frac{X_{diff}}{(N_x-1)}}$ 27:   28: ${\displaystyle {\Delta }_y\leftarrow \frac{Y_{diff}}{(N_y-1)}}$ 29:   30: ${\displaystyle {\Delta }_z\leftarrow \frac{Z_{diff}}{(N_z-1)}}$ 31:   32: ${\displaystyle {\Delta }_t\leftarrow \frac{t_{diff}}{(N_t-1)}}$ 33:   34: ${\displaystyle \Delta \leftarrow min({\Delta }_x,{\Delta }_y,{\Delta }_z,{\Delta }_t)}$ 35:   36: $N_{total}\leftarrow \prod \left(N_x,N_y,N_z,N_t\right)=2^{n_{total\_qubits}}$ 37:   Initialize system matrix $\mathbf{A}$ and vector $\mathbf{b}$ 38: $\mathbf{A}\leftarrow 0_{N_{total}\times N_{total}}$ 39:   40: $\mathbf{b}\leftarrow 0_{N_{total}\times 1}$ 41:   42: $f\leftarrow f(x,y,z,t)$ 43:   Fill $\mathbf{A}$ and $\mathbf{b}$ by iterating over all points in 4D. 44:   45: for$i_t=0$to$N_t-1$do 46:  for $i_z=0$to$N_z-1$ do 47:    for $i_y=0$to$N_y-1$ do 48:     for $i_x=0$to$N_x-1$ do 49:     $i_A\leftarrow i_t·N_z·N_y·N_x+i_z·N_y·N_x+i_y·N_x+i_x$ 50:     $\mathbf{A}[i_A,i_A]\leftarrow -2({\lambda }_x+{\lambda }_y+{\lambda }_z+{\lambda }_t)$ 51:     $\mathbf{b}\left[i_A\right]\leftarrow {\Delta }^2·f$ $\left(\mathbf{a}\right)\mathbf{X}-\mathbf{dimension}$ 52:   53:     if $i_x-1<0$ then 54:      $\mathbf{b}\left[i_A\right]\leftarrow \mathbf{b}\left[i_A\right]-{\lambda }_x·u_{x-1}$ 55:     else 56:      $i_{xminus1}\leftarrow i_t·N_z·N_y·N_x+i_z·N_y·N_x+i_y·N_x+(i_x-1)$ 57:      $\mathbf{A}[i_A,i_{xminus1}]\leftarrow {\lambda }_x$ 58:     end if 59:     if $i_x+1>N_x-1$ then 60:      $\mathbf{b}\left[i_A\right]\leftarrow \mathbf{b}\left[i_A\right]-{\lambda }_x·u_{x+1}$ 61:     else 62:      $i_{xplus1}\leftarrow i_t·N_z·N_y·N_x+i_z·N_y·N_x+i_y·N_x+(i_x+1)$ 63:      $\mathbf{A}[i_A,i_{xplus1}]\leftarrow {\lambda }_x$ 64:     end if $\left(\mathbf{b}\right)\mathbf{Y}-\mathbf{dimension}$ 65:   66:     if $i_y-1<0$ then 67:      $\mathbf{b}\left[i_A\right]\leftarrow \mathbf{b}\left[i_A\right]-{\lambda }_y·u_{y-1}$ 68:     else 69:      $i_{yminus1}\leftarrow i_t·N_z·N_y·N_x+i_z·N_y·N_x+(i_y-1)·N_x+i_x$ 70:      $\mathbf{A}[i_A,i_{yminus1}]\leftarrow {\lambda }_y$ 71:     end if 72:     if $i_y+1>N_y-1$ then 73:      $\mathbf{b}\left[i_A\right]\leftarrow \mathbf{b}\left[i_A\right]-{\lambda }_y·u_{y+1}$ 74:     else 75:      $i_{yplus1}\leftarrow i_t·N_z·N_y·N_x+i_z·N_y·N_x+(i_y+1)·N_x+i_x$ 76:      $\mathbf{A}[i_A,i_{yplus1}]\leftarrow {\lambda }_y$ 77:     end if (c) Z-dimension 78:     if $i_z-1<0$ then 79:      $\mathbf{b}\left[i_A\right]\leftarrow \mathbf{b}\left[i_A\right]-{\lambda }_z·u_{z-1}$ 80:     else 81:      $i_{zminus1}\leftarrow i_t·N_z·N_y·N_x+(i_z-1)·N_y·N_x+i_y·N_x+i_x$ 82:      $\mathbf{A}[i_A,i_{zminus1}]\leftarrow {\lambda }_z$ 83:     end if 84:     if $i_z+1>N_z-1$ then 85:      $\mathbf{b}\left[i_A\right]\leftarrow \mathbf{b}\left[i_A\right]-{\lambda }_z·u_{z+1}$ 86:     else 87:      $i_{zplus1}\leftarrow i_t·N_z·N_y·N_x+(i_z+1)·N_y·N_x+i_y·N_x+i_x$ 88:      $\mathbf{A}[i_A,i_{zplus1}]\leftarrow {\lambda }_z$ 89:     end if (d) t-dimension 90:     if $i_t-1<0$ then 91:      $\mathbf{b}\left[i_A\right]\leftarrow \mathbf{b}\left[i_A\right]-{\lambda }_t·u_{t-1}$ 92:     else 93:      $i_{tminus1}\leftarrow (i_t-1)·N_z·N_y·N_x+i_z·N_y·N_x+i_y·N_x+i_x$ 94:      $\mathbf{A}[i_A,i_{tminus1}]\leftarrow 1$ 95:     end if 96:     if $i_t+1>N_t-1$ then 97:      $\mathbf{b}\left[i_A\right]\leftarrow \mathbf{b}\left[i_A\right]-{\lambda }_t·u_{t+1}$ 98:     else 99:      $i_{tplus1}\leftarrow (i_t+1)·N_z·N_y·N_x+i_z·N_y·N_x+i_y·N_x+i_x$ 100:      $\mathbf{A}[i_A,i_{tplus1}]\leftarrow {\lambda }_t$ 101:     end if 102:     end for 103:    end for 104:  end for 105: end for 106: Output: 107:  $\mathbf{A}$  $\mathbf{b}$

The matrix A generated by our proposed algorithm for the 1D, 2D, 3D, and 4D Poisson equations are as shown in Figure 8. With slight modifications, this algorithm can be extended to any number of dimensions.

5. Results

5.1. Experimental Setup

This section is divided into three parts that focus on the description of the hardware, software, and datasets used to evaluate different multidimensional PDEs.

5.1.1. Hardware Testbed

In our experiments, we used both the noise-free (statevector) and noisy (AerSimulator) simulators to evaluate the accuracy, scalability, and total execution time of the proposed algorithm. Moreover, we have also used a hardware emulator (FakeSherbrooke) and real quantum hardware (ibm_sherbrooke and ibm_torino). Quantum system ibm_sherbrooke has 127 qubits with a decoherence time of 0.00017604 s, whereas ibm_torino has 133 qubits with a decoherence time of 0.001345 s. For all the experiments, we have used a cluster node from the University of Kansas, Lawrence, USA, equipped with a 48-core Intel Xeon Gold 6342 CPU, three NVIDIA A100 80 GB GPUs (CUDA version 11.7) with PCIe 4.0 connectivity, and 256 GB of $3200\mathrm{MHz}$ DDR4 RAM.

5.1.2. Software Frameworks

All the variants of the proposed algorithm were evaluated using Qiskit SDK (1.1.0) from IBM [26], utilizing the simulators, emulators, and real quantum hardware. As mentioned in Section 4.1, for the circuit synthesis of matrix A, we have used BQSKit[22] in Variant 1 and QuantumCircuit.unitary()[40] function of the Qiskit[26] in Variant 2. In both variants, normalized $\overrightarrow{b}$ is encoded using the highly depth-optimized classical-to-quantum (C2Q) encoding technique. For the VQE-based PDE solver experiments, we have used Qiskit SDK (0.46.0) from IBM [26] to perform tests on both noise-free and noisy environments. To convert the discretized PDE into its Pauli-based representation, the Qiskit MatrixOp [41] function is used. The ansatz used in the VQE-based PDE solver is EfficientSU2 [42] and the optimizer is ADAM [43].

5.1.3. Test Case Datasets

As a case study, we tested the multidimensional Poisson equation, i.e., 1D, 2D, and 3D with the specific source functions and boundary values (BVs) as defined below:

• 1D Poisson Equation: A source function $f\left(x\right)=10$, distance $d=X_{max}-X_{min}=1$ with the boundary values $u_{X_{-1}}=-0.6$ and $u_{X_{N_x}}=-0.7$.
• 2D Poisson Equation: A source function $f(x,y)=xy$, distance $d=1$ with boundary values (BVs) = 0, on both x and y axes.
• 3D Poisson Equation: A source $f(x,y,z)=xyz$, distance $d=1$ with boundary values (BVs) = 0, in all three axes.

5.2. Experimental Results

We benchmark our proposed algorithm with the multidimensional Poisson equation. In addition, we compared its solution profile, total execution times, and accuracy results to the VQE-based method on both noise-free and noisy simulators. Moreover, we have also obtained these results using a hardware emulator and real quantum hardware.

5.2.1. 1D Poisson Equation Results

In this section, we present the results obtained by applying our proposed algorithm to the 1D Poisson equation using noise-free and noisy simulators, as well as hardware emulators and real quantum hardware.

Noise-Free and Noisy Simulation

We conducted experiments on noise-free and noisy simulators ranging from 4 data points represented by 2 qubits up to 16,384 points represented by 14 qubits. The solution profile results from these experiments are displayed alongside the VQE-based approach in Figure 9 for 8 qubits and 14 qubits using the noise-free simulator. A strong correlation between the solution profile obtained using the noise-free simulator and the analytical solution indicates the accuracy of our proposed approach.

Figure 10 presents the solution profiles obtained using our approach along with the VQE-based approach for 8 qubits and 14 qubits on a noisy simulator, with 1 M shots (samples). The disparity between our approach and the VQE-based approach is more evident from the solution profile results on the noisy simulator, further confirming the effectiveness of our technique. A very small statistical noise as observed in Figure 10 can be further reduced by increasing the number of shots (samples). Figure 11 demonstrates that as we increase the shot count from 1 M to 32 M, the RMSE error further decreases.

We also compared the RMSE error and total time taken, see Figure 12a,b, which further confirms the accuracy, scalability, and the reduced total time of our approach compared to VQE-based technique.

Hardware Emulation

The results of our proposed approach on a hardware emulator are shown in Figure 13, with experiments using 3 qubits (8 data points) and 4 qubits (16 data points).

Figure 14a,b compares the RMSE error and total time taken by our proposed technique with 1M shots. We achieved accurate solution profile results up to 4 qubits with Variant 2. However, beyond 4 qubits, circuits generated by Variant 2 exceeded the decoherence time limit of the hardware emulator (FakeSherbrooke). In the case of Variant 1, we exceeded the decoherence time beyond 8 qubits.

We also tested the hardware emulator approach with the Pauli Twirling [44] noise mitigation technique (1 M shots). The resulting RMSE and total computation time for solving the 1D Poisson equation are presented in Figure 15a and Figure 15b, respectively. Applying Pauli Twirling noise mitigation to the hardware emulator (FakeSherbrooke) did not provide any perceptible benefits in terms of reducing the RMSE error. Our conclusion from these experiments is that noise mitigation techniques are not mature enough to significantly reduce errors and are still an active area of research.

Real Quantum Hardware

The proposed approach solution profile results of the 1D Poisson equation for real quantum hardware (ibm_sherbrooke) are presented in Figure 16. The results, shown for 3 qubits (8 data points) and 4 qubits (16 data points) on ibm_sherbrooke closely match those obtained with the hardware emulator (FakeSherbrooke). Up to 4 qubits, we achieved favorable results but exceeded the decoherence time limit of ibm_sherbrooke in Variant 2 beyond 4 qubits. However, in Variant 1, we exceeded the decoherence time limit after 7 qubits. Similarly, our solution profiles with 3 and 4 qubits on ibm_torino are shown in Figure 17. The results obtained using ibm_torino, which is based on the Heron processor comprising 133 fixed-frequency qubits, more closely resemble the analytical solution than ibm_sherbrooke. The Heron architecture delivers a performance improvement due to reduced crosstalk, faster and more accurate two-qubit gates, and improved qubit calibration [45].

Figure 18 displays the RMSE error for 1D Poisson equation for both ibm_sherbrooke and ibm_torino using 0.1 M shots. Our results indicate that the RMSE error for Variants 1 and 2 of our proposed algorithm is lower when run on ibm_torino than on ibm_sherbrooke due to its higher decoherence time owing to its improved architecture.

5.2.2. 2D Poisson Equation Results

In this section, we present the results obtained by applying our proposed algorithm to a 2D Poisson equation on noise-free and noisy simulators, as well as hardware emulators and real quantum hardware.

Noise-Free and Noisy Simulation

The solution profile for the 2D Poisson equation using noise-free simulators is illustrated in Figure 19 for 8 qubits (256 data points) and Figure 20 for 14 qubits (16,384 data points). Here, the proposed approach is compared with both classical and VQE-based techniques. The results show higher accuracy compared to the VQE-based method. However, some results for Variant 1 and the VQE-based method are not shown in Figure 20 because they could not be calculated due to the excessively long computation times.

Figure 21 presents the solution profile for the 2D Poisson equation on a noisy simulator using 1 M shots with 6 qubits (64 data points), while Figure 22 shows the solution profile for 14 qubits (16,384 data points). The solution profile results indicate that the proposed approach has a higher accuracy compared to the VQE-based approach. Note that results for Variant 1 and the VQE-based method are not included in Figure 22 due to their very long execution times.

We have also compared the proposed approach with the VQE-based technique in terms of RMSE error, see Figure 23a and the total time taken, see Figure 23b using noise-free and noisy simulators for 1 M shots. The results in terms of RMSE error and total time taken demonstrate higher accuracy and scalability, along with reduced total computational time.

Hardware Emulation

We have also evaluated the 2D Poisson equation using the proposed algorithm on a hardware emulator (FakeSherbrooke). Figure 24 presents the solution profiles obtained using 6 qubits (64 data points).

Figure 25a,b presents the RMSE error and total execution time, respectively, for the proposed method using 1 M shots. Favorable solution profiles and RMSE error results have been achieved for up to 4 qubits. Beyond 4 qubits, the circuits generated by the proposed approach exceed the decoherence time limit of the hardware emulator (FakeSherbrooke).

Real Quantum Hardware

The solution profiles of the 2D Poisson equation obtained using 4 qubits on real quantum hardware (ibm_sherbrooke) using 0.1 M shots are shown in Figure 26.

Similarly, Figure 27 shows the solution profiles obtained using 4 qubits on ibm_torino.

Figure 28 presents the RMSE error for the 2D Poisson equation on ibm_sherbrooke and ibm_torino using 0.1M shots. In the case of the 2D Poisson equation experiments on real quantum hardware, the execution time of the circuits generated by Variant 2 of the proposed approach exceeds the decoherence time limit of the quantum hardware (ibm_sherbrooke) after 4 qubits. In the case of Variant 1, this limit is exceeded after 7 qubits.

5.2.3. 3D Poisson Equation Results

In this section, we present the results obtained by applying our proposed algorithm to a 3D Poisson equation using noise-free and noisy simulators, as well as hardware emulators and real quantum hardware.

Noise-Free and Noisy Simulation

The solution profile results obtained by our approach for 6 qubits (64 data points) and 12 qubits (4096 data points), respectively, on the noise-free simulator are shown in Figure 29 and Figure 30. The results demonstrate the effectiveness of our technique, as the solution profiles closely match those produced by classical methods.

We have also investigated the efficacy of our algorithm on noisy simulators. Figure 31 and Figure 32 show the solution profile for 6 qubits (64 data points) and 12 qubits (4096 data points), respectively, using 1 M shots.

Additionally, Figure 33a and Figure 33b compares the RMSE error and the total time taken, respectively, with the VQE-based approach. These results further confirm the high accuracy, reduced total time, and scalability of our approach.

Real Quantum Hardware

We also investigated the efficiency of our proposed technique on the 3D Poisson equation using real quantum hardware. Figure 34 shows the solution profile obtained using the proposed algorithm for 6 qubits (64 data points) on quantum hardware ibm_sherbrooke. Similarly, Figure 35 shows the solution profile obtained using the proposed algorithm for 6 qubits (64 data points) on ibm_torino.

The RMSE error obtained by solving the 3D Poisson equation using ibm_sherbrooke and ibm_torino is shown in Figure 36. The solution profile and the RMSE results on the hardware emulator (FakeSherbrooke) have a similar trend to real quantum hardware.

5.3. Execution Time and Decoherence Constraint for Multidimensional Poisson on Real Quantum Hardware

In this section, we present the circuit depth, expected execution time (1 shot), and the RMSE error (0.1 M shots) for Variant 1 and Variant 2 of the proposed algorithm using a multidimensional Poisson equation as a case study on real quantum hardware (ibm_sherbrooke). These experimental results are generated by varying the number of qubits. The decoherence time used here is the median of the T2 times [24]. We have not presented similar results, such as circuit depth, expected execution time, and the RMSE error for ibm_torino because it lacks the pulse-level calibration data necessary for certain low-level quantum operations [46].

Execution Time and Decoherence Constraint for 1D Poisson Equation

This section presents a comparison of circuit depth, expected execution time (1 shot), and the RMSE error (0.1M shots) for Variant 1 and Variant 2 of our proposed algorithm applied to 1D Poisson equation, see

Table 1. Comparison of circuit depth and execution times versus the number of qubits for Variant 1 and Variant 2 of the proposed technique on real quantum hardware (ibm_sherbrooke) for 1D Poisson equation.

Qubits	Variant 1			Variant 2			Decoherence Time (ibm_sherbrooke) (Seconds)
	Circuit Depth	Expected Execution Time in Seconds (1 Shot)	RMSE Error on ibm_sherbrooke (0.1M Shots)	Circuit Depth	Expected Execution Time in Seconds (1 Shot)	RMSE Error on ibm_sherbrooke (0.1M Shots)
2	6336	0.000001408	0.029001683	6080	0.000001351	0.042829561	0.00017604
3	20,384	0.000004530	0.283069118	109,472	0.000024327	0.190385989	0.00017604
4	51,648	0.000011477	0.370884038	609,664	0.000135481	0.304748983	0.00017604
5	128,832	0.000028629	0.641067180	2,743,712	0.000609714	0.411210928	0.00017604
6	276,160	0.000061369	0.410911148	11,453,920	0.002545316	0.741372075	0.00017604
7	522,272	0.000116060	0.397343086	46,297,248	0.010288277	Error: Ran too long	0.00017604
8	1,057,504	0.000235001	0.550928878	184,545,600	0.041010133	Error: Ran too long	0.00017604
9	2,026,848	0.000450411	0.441182415	745,152,864	0.165589525	Error: Ran too long	0.00017604
10	Unrealistically long compile time	Unrealistically long compile time	Unrealistically long compile time	2,942,284,960	0.653841102	Error: Ran too long	0.00017604

. As expected, the output of the quantum circuits generated using the proposed algorithm should be affected by noise when the expected circuit execution time exceeds the decoherence time. However, the T2 time of some qubits on quantum hardware (ibm_sherbrooke) is significantly lower than the decoherence time (refer to Section 2.4). Due to this variation, the quantum circuits generated are affected by decoherence noise even before the expected execution time exceeds the decoherence time limit. As can be seen from Table 1, the quantum circuits generated using Variant 1 of our proposed algorithm are more depth-optimized than those generated using Variant 2 and hence are less affected by decoherence noise. Also, the expected execution time exceeds the decoherence time after 7 qubits in Variant 1 and after 4 qubits in Variant 2, resulting in a higher RMSE error for Variant 2.

Execution Time and Decoherence Constraint for 2D Poisson Equation

This section presents a comparison of circuit depth, expected execution time (1 shot), and the RMSE error (0.1M shots) for Variant 1 and Variant 2 of our proposed algorithm for 2D Poisson equation, see

Table 2. Comparison of circuit depth and execution times versus the number of qubits for Variant 1 and Variant 2 of the proposed technique on real quantum hardware (ibm_sherbrooke) for 2D Poisson equation.

Qubits	Variant 1			Variant 2			Decoherence Time (ibm_sherbrooke) (Seconds)
	Circuit Depth	Expected Execution Time in Seconds (1 Shot)	RMSE Error on ibm_sherbrooke (0.1M Shots)	Circuit Depth	Expected Execution Time in Seconds (1 Shot)	RMSE Error on ibm_sherbrooke (0.1M Shots)
4	45,568	0.000010126	0.002316176	605,376	0.000134528	0.00481892	0.00017604
6	290,048	0.000064455	0.005506558	11,462,912	0.002547314	0.005950357	0.00017604
8	1,019,616	0.000226581	0.006192968	183,185,952	0.040707989	Error: Ran too long	0.00017604
10	Unrealistically long compile time	Unrealistically long compile time	Unrealistically long compile time	2,988,240,992	0.664053554	Error: Ran too long	0.00017604

. As shown in Table 2, the circuit depth and the expected execution time increase with the number of qubits. Also, the RMSE error, expected execution time, and circuit depth have a similar trend as that observed for the 1D Poisson equation.

Execution Time and Decoherence Constraint for 3D Poisson Equation

The circuit depth, expected execution time (1 shot), and RMSE error (0.1 M shots) for Variant 1 and Variant 2 of our proposed algorithm for the 3D Poisson equation are shown in

Table 3. Comparison of circuit depth and execution times versus the number of qubits for Variant 1 and Variant 2 of the proposed technique on real quantum hardware (ibm_sherbrooke) for 3D Poisson equation.

Qubits	Variant 1			Variant 2			Decoherence Time (ibm_sherbrooke) (Seconds)
	Circuit Depth	Expected Execution Time in Seconds (1 Shot)	RMSE Error on ibm_sherbrooke (0.1M Shots)	Circuit Depth	Expected Execution Time in Seconds (1 Shot)	RMSE Error on ibm_sherbrooke (0.1M Shots)
6	259,712	0.000057714	0.001817507	11,478,944	0.002550876	0.00217605	0.00017604
9	2,000,192	0.000444487	0.002353428	735,210,400	0.163380089	Error: Ran too long	0.00017604

. These results also exhibit a similar trend as the 1D and 2D Poisson equations.

6. Discussion

In this section, we discuss the results generated by our proposed algorithm designed to solve multidimensional Partial Differential Equations (PDEs). We have compared our work with the VQE-based PDE solver on both noise-free and noisy simulators. Additionally, we tested our algorithm on a hardware emulator (FakeSherbrooke) and real quantum hardware (ibm_sherbrooke and ibm_torino).

6.1. Higher Accuracy

In this work, we compared the accuracy of our solution with classical and VQE-based methods in terms of RMSE error, using 1D, 2D, and 3D Poisson equations as case studies. We observed that the accuracy of our algorithm is comparable to that of classical solutions and significantly higher than that of the VQE-based approach on both noise-free (statevector) and noisy (AerSimulator) simulators. We presented our results using solution profiles and RMSE error plots. The main reason for the low accuracy in the VQE-based solution is its dependence on ansatz design [36], which often lacks sufficient expressibility [47]. This makes it inefficient to accurately approximate the solutions for multidimensional PDEs. Another reason for poor accuracy is the optimization process, which often encounters non-convex optimization landscapes [48]. We also tested Variant 1 and Variant 2 of our algorithm on a hardware emulator (FakeSherbrooke), and real quantum hardware (ibm_sherbrooke and ibm_torino) to assess its suitability for NISQ devices. With these tests, we observed that the accuracy of results remains good as long as the expected execution time of the circuits does not exceed the decoherence time of the hardware emulator or real quantum hardware.

6.2. Total Execution Time and Scalability

In our comparison of the proposed algorithm with the VQE-based solution in terms of total execution time on both noise-free (statevector) and noisy (AerSimulator) simulators, we found that our algorithm requires significantly less time than the VQE-based approach for solving the 1D, 2D, and 3D Poisson equations. This reason for exceptionally long execution time in variational-based algorithms is due to non-convergence issues caused by vanishing gradients, commonly referred to as barren plateaus. We also observed that Variant 2 executes faster than both Variant 1 and the VQE-based approach and has a scalability of up to 14 qubits. In the case of Variant 1, our scalability is only until 9 qubits, after which it takes exceptionally long execution times. Furthermore, we observed that the latest IBMQ system, ibm_torino, has a much higher decoherence time of $0.001345$ s compared to ibm_sherbrooke, which has a decoherence time of $0.00017604$ s. Since the architecture design of ibm_torino is much more immune to gate noise and environmental noise and has a 7.6× higher decoherence time compared to ibm_sherbrooke, the RMSE error generated by ibm_torino is less than that generated by ibm_sherbrooke as shown in Figure 16, Figure 17 and Figure 18 for 1D results, Figure 26, Figure 27 and Figure 28 for 2D results, and Figure 34, Figure 35 and Figure 36 for 3D results. Also, we observed that the circuits generated using Variant 2 have significantly greater depth than those generated using Variant 1. Due to this, Variant 2 is more susceptible to decoherence noise compared to Variant 1. These findings suggest that as quantum hardware technology advances, both the accuracy and scalability of our proposed algorithm will also improve on real quantum hardware.

6.3. Complexity Comparison of Proposed Approach with Classical Technique

We also conducted a circuit depth analysis of both variants of our proposed algorithm and compared it with the time complexity of the best-known classical technique [49]. Variant 1 of our proposed algorithm consists of Classical-to-Quantum (C2Q) [21] encoding and a numerical instantiation technique [22]. We have used the numerical instantiation proposed by BQSKit [22], which is a highly depth-optimized technique. Since we could not find any generalized depth complexity value for the circuits generated using BQSKit, we obtained its value through experiments using various test cases. The depth complexity of the circuit generated using BQSKit is $\mathcal{O}\left(N\right)$, where $N=2^n$ represents the number of states and n is the number of qubits. The depth complexity of the C2Q encoding technique is $\mathcal{O}\left(N\right)$[21]. The overall depth complexity of Variant 1 of the proposed technique is $\mathcal{O}\left(N\right)+\mathcal{O}\left(N\right)\approx \mathcal{O}\left(N\right)$. Variant 2 of our proposed algorithm consists of C2Q encoding and Column-by-Column Decomposition (CCD) [23]. The depth complexity of CCD is $O\left(N^2\right)$[23], and the depth complexity of C2Q is $O\left(N\right)$. Therefore, the overall depth complexity of Variant 2 is $\mathcal{O}\left(N\right)+\mathcal{O}\left(N^2\right)\approx \mathcal{O}\left(N^2\right)$. Table 1 shows that the depth of Variant 1 after around 6 qubits roughly doubles with each additional qubit. This doubling behavior corresponds to the overall depth complexity of $\mathcal{O}\left(N\right)$. In contrast, for Variant 2, the depth grows by fourfold for every additional qubit after around 6 qubits, indicating an overall depth complexity of $\mathcal{O}\left(N^2\right)$. In our analysis of the time complexity of solving a multidimensional Poisson equation using the most optimized classical computing approach of Fast Fourier Transform (FFT)-based solvers, the time complexity number is $\mathcal{O}\left(NlogN\right)$[49], where N is the number of grid points. However, with ongoing research in data encoding techniques and continuously improving compilers, we anticipate that the depth of the quantum circuits produced by the synthesis algorithms will be further optimized.

6.4. FDM Coefficient Matrix for Multidimensional Poisson Equation

We have also provided the mathematical description and procedure to convert the continuous Poisson equation into a finite difference equation for up to four dimensions. Additionally, we have also included an algorithm to compute the coefficient matrix and the vector representing the source of the Poisson equation up to four dimensions. With minor modifications, this algorithm can be extended to handle any number of dimensions. This description is included to make it easier to implement our proposed algorithm and its extension to higher dimensions.

7. Conclusions

In this work, we present a generalized quantum algorithm designed to efficiently and accurately solve multidimensional Partial Differential Equations (PDEs) using Quantum-Centric High-Performance Computing (QC-HPC). The algorithm is developed in two distinct forms: the first variant employs the Finite Difference Method (FDM), numerical instantiation, and Classical-to-Quantum (C2Q) encoding whereas the second variant uses FDM, C2Q encoding, and Column-by-Column Decomposition (CCD). To demonstrate the effectiveness of our technique, we have used the multidimensional Poisson equation as a case study. The results showed superior accuracy, scalability, and faster execution times compared to PDE solvers based on Variational Quantum Algorithms (VQAs) on both noise-free and noisy simulators, as well as hardware emulators, and real quantum hardware from IBM simulators. We have also provided a generalized algorithm that computes the coefficient matrix and the vector representing the source of the Poisson equation up to four dimensions. With minor modifications, this algorithm can be extended to handle any number of dimensions and can solve various types of PDEs. We also tested various noise mitigation techniques, especially Pauli Twirling and concluded that these techniques are still not mature enough to significantly improve circuit execution results on quantum emulators or real quantum hardware. However, noise mitigation techniques are still an active area of research and are continuously improving. With ongoing research in the field of data encoding techniques, continuously improving compilers, rapid progress in noise mitigation techniques, and advancements in quantum hardware, we anticipate that our proposed algorithm will be further optimized on quantum simulators, emulators, and real quantum hardware.