Design parallel and sequential quantum algorithms via spectral element method on distributed quantum architectures Authors: Amir Hossein Salehi Shayegan Published: 2025 ABSTRACT AbstractIn this work, we present a solution to the critical limitation of qubit capacity in near-term quantum hardware by giving a hybrid framework that integrates the spectral element method (SEM) with distributed quantum computing. Using domain decomposition techniques, the additive and multiplicative Schwarz methods, the global problem is divided into smaller subproblems that each require significantly fewer qubits, making them suitable for current quantum devices. The HHL algorithm is applied locally to these subproblems, enabling quantum speedups without exceeding hardware constraints. Numerical results validate the approach, demonstrating a scalable and practical solution for high-accuracy simulations despite qubit limitations.Keywords: Distributed quantum computing, Spectral element method, Quantum algorithmsSubject terms: Mathematics and computing, Physics Introduction Consider the parabolic problem: where , and . The numerical solution of partial differential equations plays a crucial role in modeling and simulating complex physical systems in fields such as fluid dynamics, electromagnetics, and structural mechanics. Among high-accuracy discretization techniques, the spectral element method has gained prominence for its ability to achieve exponential convergence rates while maintaining geometric flexibility1–4. SEM combines the advantages of spectral methods and finite element methods by partitioning the domain into elements and employing high-degree polynomial basis functions within each element. Despite its accuracy, the global linear systems arising from SEM discretizations can be computationally intensive, especially for high-resolution or multidomain problems. Meanwhile, quantum computing offers the potential to transform numerical linear algebra by providing speedups for certain classes of problems. In particular, the Harrow-Hassidim-Lloyd (HHL) algorithm enables the quantum solution of linear systems of equations with exponential complexity improvements under specific conditions5. These features make HHL a compelling candidate for accelerating the solution of the linear systems that emerge from SEM discretizations. However, the practical realization of quantum algorithms such as HHL is currently constrained by the hardware limitations of near-term quantum devices, often referred to as Noisy Intermediate-Scale Quantum (NISQ) systems. These devices typically support only a limited number of coherently controllable qubits, which restricts the size and complexity of problems that can be processed quantum-mechanically in a single execution. Moreover, quantum gates are inherently error-prone, and the accumulation of gate errors and decoherence effects severely limits the circuit depth and algorithmic fidelity achievable on current machines. As a result, executing large-scale or high-precision computations solely on quantum hardware is presently infeasible. These limitations have prompted the development of hybrid quantum-classical approaches, where the quantum processor is used for specific subroutines, such as solving linear systems or performing eigendecompositions, while the classical processor manages overall data orchestration, pre/post-processing, and the parts of the algorithm that do not benefit from quantum speedup. This division of labor is essential for realizing practical quantum advantage in computational science, especially when integrating quantum solvers with large-scale classical methods such as the spectral element method. To overcome these challenges, this work proposes an integrated framework that couples distributed quantum computing with SEM. Distributed quantum computing leverages multiple interconnected quantum processors (nodes) to collaboratively perform quantum computations beyond the capacity of a single device6,7. By distributing the workload across quantum nodes and using entangled communication channels, the framework facilitates scalable quantum computation. Within this architecture, we design parallel and sequential quantum algorithms that match the decomposition structure of SEM, enabling efficient hybrid execution. A core innovation in our approach is the use of domain decomposition methods, namely the additive Schwarz method and the multiplicative Schwarz method, tailored for quantum implementation8. The additive Schwarz method lends itself to parallel execution, as each subdomain problem can be solved independently, which aligns well with parallel quantum subroutines running on separate quantum nodes. On the other hand, multiplicative Schwarz method uses a sequential update mechanism, making it well-suited for sequential quantum execution with state reuse and entanglement-aware scheduling. These methods help improve convergence when using quantum linear solvers such as HHL and balance computational cost with inter-node communication. By integrating quantum speedups through the HHL algorithm with the spectral accuracy of SEM and the parallelism of additive Schwarz method and multiplicative Schwarz method, the proposed framework aims to deliver scalable and high-performance solvers for complex physical simulations. Preliminary numerical experiments indicate that the framework not only improves computational efficiency but also adapts well to near-term quantum architectures. This work contributes to bridging classical high-order numerical methods with emerging quantum technologies, paving the way for future advances in scientific computing. This paper is structured as follows. Section "Spectral element method" provides an overview of the spectral element method and its mathematical foundations. Section "Distributed quantum computing framework" introduces the distributed quantum computing framework and details the implementation of the additive and multiplicative Schwarz methods as domain decomposition strategies. In Sect. "Parallel and sequential quantum algorithm design", we present the proposed parallel and sequential quantum algorithms developed within this hybrid framework. Finally, Sect. “Numerical results” illustrates the effectiveness of the proposed approach through a numerical example, demonstrating its computational efficiency and scalability. Spectral element method In this section, we discuss the spectral element method, a high-order numerical technique for solving partial differential equations. SEM combines the strengths of two established methods: the finite element method (FEM) and the spectral method (SM). The high accuracy of SEM is inherited from the spectral approach, while its flexibility and geometric adaptability stem from the finite element framework1,9,10. In the following, we provide a brief overview of this method. The spectral element method begins with the spatial discretization of the problem. To achieve this, we first multiply both sides of equation (1) by a test function , and then integrate over the domain to obtain: The second step of SEM involves partitioning the model domain into subdomains. Similar to FEM, the domain is divided into non-overlapping subdomains (elements) denoted by : Hence, the integrals in equation (4) can be evaluated independently over each subdomain, so one can write: for . Then, each integral in equation (5) is approximated using the Gauss-Lobatto-Legendre (GLL) quadrature. To do this, each element is mapped onto the standard reference interval . In this method, the collocation points are defined as: where is the Legendre polynomial of degree . The corresponding weights for the numerical integration are given by For more details, see10. Now, if in equation (5) we approximate the solution as: and choose the test function as then we obtain the following semi-discrete formulation for : We note that , for , are the Lagrange interpolating polynomials associated with the nodes: where is the mapping function that transforms the reference nodes , , on the standard interval to the corresponding nodes on the physical element . Figure 1 illustrates the idea of dividing the model domain into elements on the basis of a one-dimensional string. Each element domain is then transformed as shown for element number 1. Decomposition and mapping. Here the model is divided into three elements and also the degree of Legendre polynomial is . To approximate the first integral in equation (7) using GLL quadrature, we write: where denotes the Jacobian of the transformation. Similarly, for the second and third integrals, we have: and After computing the matrix form of all integrals within each element individually, the next step is the assembly process. In the case of one-dimensional elements, we begin by defining a local-to-global node mapping (denoted as LtoG), which assigns the local node indices of each element to the corresponding global node indices in the mesh. For example, as illustrated in Fig. 1, the local-to-global node mapping matrix is given by: Each row corresponds to the local node numbering of an element and each entry represents the associated global node number. There are rows and columns in the LtoG matrix. The th row contains the global node numbers associated with the th element. Using this mapping, the global matrices M, K and F are assembled by looping over each element and adding contributions of the local matrices to the corresponding global entries. Shared nodes naturally accumulate contributions from multiple elements. This procedure ensures that the assembled global matrices correctly represent the entire domain and can then be used in the solution of the finite element system (Algorithm 1). Global Matrix Assembly using LtoG Mapping Using the assembly rule11 and the LtoG matrix, we ultimately obtain the following system of equations (Algorithm 1): where, for and (see Fig. 1), the system matrices are assembled as follows: We solve the system of ordinary differential equations (9) using the backward Euler method (Algorithm 2). We discretize the time interval into uniform steps of size , and define the discrete time levels by Accordingly, we denote the approximate solution and forcing term at time as Implicit Backward Euler Method for Solving Remark 2.1 The backward Euler method is a first-order accurate time integration scheme. It is consistent with local truncation error of order and globally convergent with an error of order . Due to its unconditional stability (A-stability), the method is particularly effective for stiff systems and guarantees convergence as 12. We note that the matrix A in Algorithm 2 exhibits the following sparsity pattern and remains constant throughout all iterations: where each “” denotes a potentially nonzero entry. This block structure exhibits banded and overlapping blocks, which naturally lend themselves to decomposition and parallel processing. Accordingly, we implement this matrix within a distributed quantum computing framework, where each subsystem handles a portion of , exploiting its sparsity to optimize quantum resources and improve computational efficiency. This approach effectively addresses the limitation on the number of qubits available in current quantum computers by distributing the problem across smaller quantum subsystems. Distributed quantum computing framework Distributed quantum computing is an emerging paradigm that connects multiple smaller quantum processors (or quantum nodes) through quantum communication channels to collaboratively solve complex computational problems13,14. Instead of relying on a single large-scale quantum computer, which remains challenging due to technological and physical constraints, this framework enables scalability by partitioning tasks across interconnected quantum systems15. In this approach, quantum information and entanglement are shared between nodes, allowing them to perform joint quantum algorithms and computations that exceed the capability of any individual processor16. Distributed quantum computing leverages the combined power of multiple quantum devices, overcoming limitations such as restricted qubit counts, error rates, and coherence times17. By decomposing large problems into smaller subproblems handled by separate quantum nodes, distributed quantum computing enhances flexibility, fault tolerance, and resource efficiency. This makes it a promising route toward practical quantum advantage and enables applications in quantum simulation, optimization, and secure communication18,19. Domain decomposition methods for solving linear system of equations When the system size is large, direct solution methods become computationally expensive or infeasible. Domain decomposition methods offer an effective approach to solving such systems by breaking the problem into smaller subproblems associated with subdomains of the original computational domain. The domain decomposition approach consists of the following steps: Partitioning: The computational domain is partitioned into for example overlapping or non-overlapping subdomains. Correspondingly, the global system matrix and vectors , are decomposed into local parts associated with these subdomains. Partitioning: The computational domain is partitioned into for example overlapping or non-overlapping subdomains. Correspondingly, the global system matrix and vectors , are decomposed into local parts associated with these subdomains. Local subproblems: For each subdomain, define a restriction operator that extracts local degrees of freedom from the global system. Then, the local system matrix on subdomain is and the local right-hand side is Local subproblems: For each subdomain, define a restriction operator that extracts local degrees of freedom from the global system. Then, the local system matrix on subdomain is and the local right-hand side is Iterative Solution: The global solution is approximated by iteratively solving these smaller local systems and combining their solutions. Corrections from local solves are propagated across subdomains through overlapping regions or interface conditions. Iterative Solution: The global solution is approximated by iteratively solving these smaller local systems and combining their solutions. Corrections from local solves are propagated across subdomains through overlapping regions or interface conditions. Two main classes are commonly used, overlapping domain decomposition and non-overlapping domain decomposition. In overlapping methods, subdomains share common regions. This overlap facilitates information exchange and accelerates convergence. Schwarz methods (both additive and multiplicative) are typical examples, where local solves on overlapping subdomains iteratively update the global solution. Also, in non-overlapping methods, subdomains meet only at interfaces without overlap. Interface conditions and constraints are imposed to ensure continuity and compatibility. Examples include the Schur complement methods and the finite element tearing and interconnecting (FETI) methods. Domain decomposition methods offer several advantages, including inherent parallelization since local subproblems can be solved concurrently, which makes these methods well-suited for distributed computing architectures. They also reduce memory usage and computational cost by breaking a large system into many smaller, more manageable systems that are typically more efficient to solve. Additionally, domain decomposition provides flexibility, allowing different numerical methods or discretizations to be applied to different subdomains according to local problem characteristics. Finally, these methods enhance scalability, enabling the solution of very large problems that would otherwise be computationally intractable. Schwarz methods Schwarz methods20 are classical iterative techniques where the solution is updated through sequential or parallel subdomain solves, with information exchanged via overlapping regions. Two principal variants of Schwarz methods exist: the Additive Schwarz method, where subdomain corrections are computed simultaneously in parallel and then combined to update the global solution, and the Multiplicative Schwarz method, in which subdomain solves are performed sequentially, with each subdomain using the most recently updated global solution before moving to the next. To be exact, we aim to solve the linear system: where . For simplicity, we assume that (Fig. 1). Decomposing the matrix as where each corresponds to a block contribution to the global matrix. Each block arises from a local matrix . Define restriction matrices that extract the relevant global degrees of freedom: Each local matrix is defined as: The contribution to the global system is then given by: In Algorithm 3 and Algorithm 4, we give additive and multiplicative Schwarz methods respectively for . Additive Schwarz Method Multiplicative Schwarz Method The additive Schwarz method enables parallel computation by dividing the global problem into overlapping subdomains, where each subproblem can be solved independently. In each iteration, the solution on each subdomain is computed using the current global estimate, and all subdomain solutions are calculated simultaneously. Once all local problems are solved, their contributions are combined to update the global solution. This independence makes additive Schwarz method highly suitable for distributed computing environments, where multiple processors or cores can work on different parts of the domain at the same time. In contrast, the multiplicative Schwarz method is inherently sequential. Here, subdomain problems are also solved one at a time, but the key difference is that the solution is updated after each subdomain solve. This means the next subdomain uses the most recent information from the previous update, which often results in faster convergence, similar to the way Gauss-Seidel works compared to Jacobi iteration. However, because each subdomain relies on the result of the previous one, multiplicative Schwarz method cannot be parallelized easily and is typically used in serial computation environments. Parallel and sequential quantum algorithm design Before presenting our proposed parallel and sequential quantum algorithms, we first review the foundational of HHL quantum algorithm5. The HHL algorithm provides a quantum approach to solving linear systems with exponential speedup under certain conditions. This algorithm serves as the theoretical foundation for our proposed quantum algorithms. Overview of the HHL quantum algorithm As a result of discretizing the partial differential equation, the problem is reduced to solving a linear system of equations: where is a Hermitian matrix, and is derived from the source term and boundary conditions. Although classical algorithms require polynomial time to solve such systems, quantum computing provides a framework for exponential acceleration through the use of the HHL algorithm5,21,22,24–26. The HHL algorithm comprises three main stages: quantum phase estimation (QPE), controlled rotation, and uncomputation. The process begins by encoding the input vector into a quantum state . QPE is then used to extract the eigenvalues of the matrix , which are stored in an ancillary register. A controlled rotation is subsequently applied to an auxiliary qubit, with rotation angles determined by the reciprocals . Finally, the inverse QPE (uncomputation) is performed to disentangle the eigenvalue register, resulting in a quantum state that approximates the solution to the linear system. Let be a Hermitian matrix with spectral decomposition: where are the eigenvalues and are the corresponding orthonormal eigenvectors. Since is diagonalizable in the eigenbasis , its inverse can be expressed as Assuming that the input vector admits the decomposition the solution to the linear system is given by which the HHL algorithm approximates as a quantum state. The quantum circuit implementing the HHL algorithm utilizes three main quantum registers. The first register, consisting of qubits, encodes the input vector as a quantum state , and ultimately holds a state proportional to the solution . The second register, of size , stores the binary representation of the eigenvalues obtained via QPE. Additionally, an ancillary qubit is used to perform a controlled rotation, where the rotation angle is inversely related to the estimated eigenvalues. This step effectively simulates the action of the matrix inverse required to solve the linear system. Initially, all qubits are initialized in the state. The state is prepared by applying an appropriate unitary transformation to the -qubit register. QPE is then performed using controlled applications of the unitary operator , where is the Hermitian matrix associated with the system , and is a selected evolution time. The resulting eigenvalues are encoded in the -qubit register. Subsequently, a controlled rotation is applied to the ancillary qubit, conditioned on the contents of the eigenvalue register. This operation maps the amplitude of the ancillary qubit to be proportional to , thereby encoding the reciprocal of the eigenvalues. Next, inverse quantum phase estimation () is applied to uncompute the eigenvalue register and disentangle it from the system. Finally, a measurement is performed on the ancillary qubit. If the measurement outcome is , the post-measurement state of the -register is proportional to the desired solution . The HHL algorithm consists of the following key subroutines: State Preparation: The input vector is normalized and encoded into a quantum state expressed in the eigenbasis of matrix : State Preparation: The input vector is normalized and encoded into a quantum state expressed in the eigenbasis of matrix : Quantum Phase Estimation (QPE): This step estimates the eigenvalues associated with eigenvectors by applying controlled time evolution , followed by an inverse quantum Fourier transform (QFT) on the ancilla register. The resulting state is: where denotes the number of qubits used to represent eigenvalues with finite precision. Quantum Phase Estimation (QPE): This step estimates the eigenvalues associated with eigenvectors by applying controlled time evolution , followed by an inverse quantum Fourier transform (QFT) on the ancilla register. The resulting state is: where denotes the number of qubits used to represent eigenvalues with finite precision. Eigenvalue Inversion via Controlled Rotation: A controlled rotation is applied to an ancillary qubit based on the estimated eigenvalues, encoding the reciprocal into the amplitude: where is a scaling constant such that , ensuring valid rotation angles. Eigenvalue Inversion via Controlled Rotation: A controlled rotation is applied to an ancillary qubit based on the estimated eigenvalues, encoding the reciprocal into the amplitude: where is a scaling constant such that , ensuring valid rotation angles. Uncomputation: The QPE operation is reversed to disentangle the eigenvalue register: Uncomputation: The QPE operation is reversed to disentangle the eigenvalue register: Measurement: Measuring the final ancilla qubit and obtaining outcome collapses the state to one proportional to the solution vector : which approximates the desired result up to normalization. The process may be repeated until this outcome is observed. Measurement: Measuring the final ancilla qubit and obtaining outcome collapses the state to one proportional to the solution vector : which approximates the desired result up to normalization. The process may be repeated until this outcome is observed. Post-Processing: If an observable is of interest, its expectation value with respect to can be computed as: Post-Processing: If an observable is of interest, its expectation value with respect to can be computed as: Parallel quantum algorithm In this subsection, we present a parallel quantum algorithm for solving the partial differential equation (1)–(3). Also in Fig. 2 the schematic of the parallel quantum algorithm is given. Schematic of parallel quantum algorithm. Sequential quantum algorithm In this subsection, we present a sequential quantum algorithm for solving the partial differential equation (1)–(3). Also in Fig. 2 the schematic of the sequential quantum algorithm is given. Schematic of sequential quantum algorithm. HHL output and result composition The HHL algorithm outputs a quantum state which encodes the normalized classical solution vector of the linear system in its probability amplitudes. During computation, the ancilla qubit in the HHL circuit controls the eigenvalue inversion process. Measuring the ancilla in the state collapses the system qubits into a state proportional to the desired solution: where and denote the eigenvalues and eigenvectors of , and . Since this measurement is probabilistic, multiple repetitions may be required to obtain the outcome. The resulting quantum state encodes the solution information in its amplitudes, which cannot be directly accessed by a single measurement. Instead, properties of are inferred through quantum state tomography or by estimating expectation values of specific observables, depending on the hardware capabilities and target quantities. Quantum state tomography Full quantum state tomography enables comprehensive characterization of the quantum state produced by the HHL algorithm through a series of projective measurements performed in multiple bases. By repeatedly measuring identically prepared instances of the output state in complementary bases associated with the Pauli operators , and , the corresponding density matrix can be reconstructed as: The reconstructed density matrix reveals both population probabilities and coherence terms. From these quantities, the amplitude coefficients of the classical solution vector can be extracted. For small-scale systems, full tomography is practical and allows accurate verification of the quantum solution. For larger systems, specific expectation values can be efficiently estimated using techniques such as quantum amplitude estimation, without requiring full state reconstruction. On NISQ devices, tomography is used mainly to characterize small systems of up to about 5–10 qubits. In fault-tolerant architectures, observables such as can be obtained more efficiently using amplitude estimation or other protocols, eliminating the need for full tomography. Also, in some classical simulation environments (e.g., Mathematica’s QuantumCircuitOperator), the full amplitude vector can be directly extracted and normalized to recover the classical solution . Result composition and post-processing After obtaining the reconstructed local solutions from each HHL quantum solver, the results are assembled through a classical post-processing step following the domain decomposition strategy. In the parallel quantum algorithm, all subdomain corrections are combined simultaneously using the additive Schwarz update rule: This formulation preserves global continuity while enabling concurrent quantum computation across distributed subdomains, providing a scalable approach for parallel implementation on multiple quantum processors. In contrast, the sequential quantum algorithm employs the multiplicative Schwarz strategy, where each subdomain solution is incorporated into the global approximation immediately after computation. The update is performed as: This sequential process ensures that boundary corrections are progressively propagated through the domain, leading to improved numerical stability and faster convergence in strongly coupled systems. Density matrix reconstruction for the two-qubit HHL output For the two-qubit HHL implementation, full quantum state tomography reconstructs the complete density matrix in the Pauli basis: where and are the measured expectation values. Projective measurements in multiple bases on identically prepared copies of allow reconstruction of both diagonal and off-diagonal elements, capturing population probabilities and coherence terms. Using these statistics, the reconstructed density matrix fully characterizes the quantum state, enabling comparison with the theoretical prediction and validation of the HHL implementation’s accuracy and fidelity (see Fig. 4). Schematic of full quantum state tomography for reconstructing the coefficients of a 2-qubit HHL output state. In next section, the application of the proposed algorithms to solve the problem (1)–(3) is shown by an example. Numerical results To demonstrate the efficiency of the proposed algorithms, we present a numerical example in this section. Let the final time be , and set the number of time steps to , yielding a time step size of . For simplicity, we compute only the first time step . Specifically, we solve the following linear system: using both the proposed parallel and sequential quantum algorithms. In SEM, the partial differential equation (1)–(3) is discretized over elements, and the degree of the Legendre polynomial basis is chosen as . Also, classical computations were performed using Mathematica 14.0 on a desktop computer equipped with a Pentium(R) Dual-Core CPU E5700 @ 3.00 GHz. The quantum implementation of the proposed algorithm was conducted using the IBM Quantum simulator, accessed through the Qiskit framework. Qiskit is an open-source quantum computing software development kit that provides tools for designing, simulating, and executing quantum algorithms on both simulators and real quantum hardware. The use of the IBM simulator offers a reliable and noise-free environment for evaluating the behavior of quantum circuits, ensuring that the algorithm operates as theoretically expected. This simulation environment plays a crucial role in the development pipeline, as it allows for extensive testing and debugging of the quantum algorithm prior to execution on actual quantum devices, which are currently limited by noise, decoherence, and qubit connectivity constraints. Now, consider the partial differential equation (1)–(3), where the exact solution is: So, we have . Applying SEM, the matirx is obtained by: and is obtained by Now, we apply the proposed parallel and sequential quantum algorithms. The -norm errors and the relative errors of the proposed method for 10 iterations in the additive and multiplicative Schwarz methods are listed in Table 1. For the function u(x, t) defined on the domain , the -norm error at time is defined as: and the corresponding relative error is Here, is the exact solution of the PDE and is the solution obtained from the HHL-based quantum algorithm. In addition, the exact solution and the approximate solution for is demonstrated in Figs. 5 and 6 with the proposed parallel and sequential quantum algorithms, respectively. In these figures and table, we clearly observe that the desired solution is provided by the approximate solution as well. Table 1The -norm errors and the relative errors of the proposed method.NMethodError-norm error103Classical additive Schwarz method103The parallel quantum algorithm103Classical multiplicative Schwarz method103The sequential quantum algorithmRelative error103Classical additive Schwarz method103The parallel quantum algorithm103Classical multiplicative Schwarz method103The sequential quantum algorithm The -norm errors and the relative errors of the proposed method. The plots of exact and the approximate solutions with the proposed parallel quantum algorithm. The plots of exact and the approximate solutions with the proposed sequential quantum algorithm. The quantum circuit implementation of the HHL algorithm required a total of 7 qubits (see Fig. 7), allocated across three primary roles: eigenvalue encoding via quantum phase estimation, state representation of the input vector, and an ancillary qubit for the controlled rotation step. In the context of the proposed parallel and sequential quantum algorithms, this qubit structure serves as a foundational unit. For the parallel quantum algorithm, multiple HHL circuits can be executed simultaneously across distributed quantum nodes, each solving a local subdomain system as dictated by the additive Schwarz method. Each node replicates the 7-qubit configuration independently, enabling concurrent processing and efficient scalability. In contrast, the sequential quantum algorithm, aligned with the multiplicative Schwarz method, reuses a single HHL circuit structure iteratively. The state is updated after each subdomain solve and passed to the next, preserving inter-domain dependencies. This reuse minimizes qubit overhead while maintaining consistency across the computational domains. Together, these strategies highlight how the modular HHL circuit can be adapted to support scalable, domain-decomposed quantum solutions to large linear systems. The circuit implements the HHL quantum algorithm. Circuit-92 performs the state preparation using amplitude encoding, initializing the quantum state . The qubits and form the state register that stores , while q6 serves as an ancilla qubit for controlled rotations. The qubits and make up the eigenvalue register, which holds the results of the Quantum Phase Estimation (QPE) subroutine. The 1/x gate implements eigenvalue inversion and denotes the inverse (dagger) of QPE, which uncomputes the eigenvalue register to disentangle it from the state register. Conclusion This paper studied one of the most pressing challenges in applying quantum algorithms to scientific computing: the limited number of qubits available in near-term quantum processors. Instead of requiring a large quantum system to solve global problems directly, we introduced a distributed strategy that decomposes the global system into smaller subdomain problems, each solvable with far fewer qubits. By integrating the spectral element method with both additive and multiplicative Schwarz domain decomposition methods, we developed quantum-compatible formulations that map effectively to parallel and sequential execution models, respectively. Notably, each subproblem fits within the modest qubit capacities of current quantum hardware. This architecture allows multiple HHL-based solvers to run in parallel across quantum nodes (in the additive case) or iteratively on a single device (in the multiplicative case), making full use of limited quantum resources without sacrificing the accuracy and convergence properties of high-order spectral methods. Rather than being a theoretical abstraction, the proposed method offers a realistic and scalable pathway toward applying quantum algorithms to large-scale partial differential equations. As quantum hardware matures, the modular and qubit-efficient nature of this framework makes it well-positioned for early adoption in hybrid high-performance computing environments. Author contributions Amir Hossein Salehi Shayegan affirms full responsibility for all aspects of this research, including its conceptualization, methodological design, implementation, data analysis, manuscript preparation, and final revisions. Funding The author declares that no financial support was received for the research, authorship, or publication of this article. Data availability The datasets used and/or analysed during the current study available from the corresponding author on reasonable request. Declarations Competing interests The authors declare no competing interests. Footnotes Publisher’s note Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations. References Associated Data Data Availability Statement The datasets used and/or analysed during the current study available from the corresponding author on reasonable request.