⚛️ quantum physics

PyQLAS: A Quantum-Classical Hybrid Solver Library for Linear Systems

This paper introduces PyQLAS, a quantum-classical hybrid library that enables scalable solutions for linear systems by dynamically apportioning computational tasks between quantum and classical components, allowing the quantum circuit width to remain fixed while the classical host handles problem growth, and validates this approach on the IEEE 118-bus power flow system with high accuracy.

Original authors: Meng-Han Dou, Teng-Yang Ma, Chuang-Chao Ye, Zhao-Yun Chen, Guo-Ping Guo

Published 2026-11-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Meng-Han Dou, Teng-Yang Ma, Chuang-Chao Ye, Zhao-Yun Chen, Guo-Ping Guo

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the vast landscape of modern engineering, from designing aircraft wings to managing the flow of electricity across a continent, a single type of mathematical problem appears again and again. These are systems of linear equations, which can be thought of as a massive set of interconnected rules that must all be satisfied at once. Imagine trying to balance a complex scale where moving one weight shifts the entire structure; finding the correct balance point is the core task of these calculations. For decades, engineers have relied on powerful classical computers to solve them, but as the problems grow larger and more intricate, the time required to find an answer can stretch into days or even become impossible. Quantum computing offers a tantalizing promise to solve these specific problems much faster, potentially shrinking a task that takes years into seconds. However, the quantum machines available today are small, fragile, and prone to errors, meaning they cannot yet tackle these massive problems on their own. The challenge for scientists is not just to build a faster quantum computer, but to figure out how to make a small, noisy quantum device work in perfect harmony with a classical computer to solve a problem that is too big for either to handle alone.

A team of researchers has addressed this challenge by creating a new software library called PyQLAS, which acts as a bridge between the quantum and classical worlds. Rather than treating the quantum computer as a standalone magic box, this system treats it as a specialized tool that handles a small, bounded part of the work, while the classical computer manages the heavy lifting of the overall process. The researchers built three distinct layers of solvers around a single quantum engine. The innermost layer uses the quantum device to find a rough answer to a simplified version of the problem. The middle layer takes that rough answer and uses the classical computer to correct the remaining errors. The outermost layer adds a further layer of classical refinement, projecting the solution onto a stable mathematical space. This design allows the quantum part of the calculation to stay small and fixed in size, regardless of how large the actual engineering problem becomes. The classical computer absorbs the growth, handling the complexity that the quantum device cannot yet manage.

To test if this approach works in the real world, the team applied their library to a standard, difficult problem used by electrical engineers: calculating the flow of power through a grid with 118 connection points. This is a nonlinear problem, meaning the equations change as the solution is found, requiring the computer to solve a linear system over and over again inside a larger loop. The researchers ran this simulation on a classical computer that mimics a perfect quantum machine, as well as on a real, noisy superconducting quantum processor available through a cloud service. They found that their hybrid system could successfully navigate the entire process. When the system encountered a difficult step where the equations were poorly balanced, the software automatically adjusted the problem to make it solvable, a process known as preconditioning. The final result was a solution that matched the established classical reference with extreme precision, differing by less than 0.000000023 in voltage magnitude and less than 0.0000034 degrees in voltage angle.

The study revealed that the key to success was not just the quantum algorithm itself, but how the work was divided. The researchers found that if they tried to let the quantum computer do too much, the solution would fail, especially when the problem was large or the equations were difficult. However, by keeping the quantum circuit small and fixed, and letting the classical computer handle the iterations and corrections, the system remained stable. They also discovered that a specific type of internal adjustment, called an inner preconditioner, was crucial for helping the quantum part succeed on difficult problems, boosting the success rate from a mere 15 percent to about 80 percent in certain tests. Conversely, they showed that a separate, external adjustment helped reduce the total time and resources needed, making the process about 650 times faster in terms of the time spent waiting for the quantum device, without changing the final answer.

This work demonstrates that the path forward for quantum computing in engineering is not to wait for perfect, error-free machines, but to build robust systems that can function with the imperfect tools we have today. The researchers showed that by carefully apportioning the labor, a small quantum device can be embedded into existing engineering workflows without breaking them. The library they created allows engineers to swap a simulator for a real quantum processor with a single line of code, keeping the rest of their complex simulation unchanged. The results suggest that while quantum computers are not yet ready to replace classical ones, they are ready to become a useful, integrated part of the engineering toolkit, provided they are guided by a classical host that knows how to manage their limitations. The team concluded that for practical applications, the most effective strategy is to use the most advanced hybrid solver available, enable the internal adjustments to ensure stability, and choose the right computing environment for the stage of the work, using perfect simulations for development and real hardware for final validation.

Technical Summary: PyQLAS – A Quantum-Classical Hybrid Solver Library for Linear Systems

Problem Statement

Linear systems form the computational core of engineering practice, arising from discretizations of partial differential equations and requiring repeated solutions within implicit time steps, Newton iterations, and parameter sweeps. These systems are often large-scale and ill-conditioned. While quantum algorithms (e.g., HHL) offer asymptotic advantages, current hardware limitations—specifically the lack of error correction and long coherent evolution—prevent their direct application. Existing software frameworks (e.g., Qiskit) provide execution substrates but lack integrated linear solvers, forcing users to manually assemble solvers, iteration loops, and resource controls. Furthermore, variational linear solvers are typically distributed as single-layer prototypes lacking essential engineering features like preconditioning, dimension alignment, and checkpointing.

The core challenge addressed is the lack of a stable, reusable engineering component that effectively divides labor between a noisy quantum device and a classical host. A practical solver must accept application-generated matrices, return verifiable results, and behave predictably on difficult systems without requiring the user to redesign the algorithm for every hardware constraint.

Methodology

The authors present PyQLAS, a productized Python library designed to solve linear systems ( $Ax=b$ ) on quantum and hybrid backends. The library's architecture is defined by a deliberate division of labor: the quantum device executes a bounded variational subroutine, while the classical host manages the iteration, convergence, resource budget, and preconditioning.

Architecture

PyQLAS is organized into two primary layers:

Solver Layer: Built around a single variational core (QOptimizer), the library exposes three nested solvers:
- VQSolver: Treats $Ax=b$ as a single variational problem.
- IVQSolver: Wraps VQSolver in an outer iteration that corrects the residual.
- GVQSolver: Wraps IVQSolver with a Krylov-subspace projection (GMRES).
- Key Design Feature: As one moves outward from VQ to GVQ, the quantum circuit width remains fixed, while the classical host absorbs the increasing computational load (iteration control, residual bookkeeping, subspace projection). This allows the quantum load to be rebalanced elastically against the classical load.
Execution Layer: Provides a backend-agnostic interface via QTask (immutable task description) and QMachine (stateful executor). It supports three backends:
- State: Exact state-vector simulator.
- Dummy: Local sampler (probabilistic).
- Cloud: Real superconducting processor (OriginQ).

Preconditioning Strategy

The library implements two independent levels of preconditioning:

Outer Preconditioner: A classical function (Preconditioner) applied before solver construction. It performs incomplete LU (ILU) factorization to lower the condition number and pads the system dimension to the nearest power of two (using a decoupled identity block) to meet solver requirements.
Inner Preconditioner: Integrated within the solver (prec_lev argument), acting on the operator minimized by the variational core to extend the range of solvable condition numbers.

Workflow

The workflow accepts matrix and right-hand side arrays, optionally applies the outer preconditioner, selects a solver layer, and executes the iterative loop. The system supports checkpointing to resume interrupted solves and enforces device budgets (task counts and time limits).

Key Contributions

Productized Hybrid Library: Unlike algorithmic demonstrations, PyQLAS is a stable engineering component with a small, fixed interface that hides complex internal machinery (nested solvers, preconditioning, resource management).
Elastic Resource Allocation: The nested solver design allows the quantum circuit width to remain constant while the classical host scales to handle larger problems or stricter convergence requirements.
Backend Portability: The same code runs unmodified on exact simulators, local samplers, and real quantum processors.
Dual Preconditioning: The separation of outer (classical, dimension/conditioning) and inner (variational, convergence) preconditioning provides a flexible toolkit for handling ill-conditioned systems.

Results

The library was validated on synthetic systems and the IEEE 118-bus power flow problem, a standard engineering test case involving ill-conditioned Jacobians within a Newton-Raphson iteration.

Performance on Synthetic Systems

Qubit Scaling: For the base VQSolver, success rates drop sharply as qubit count ( $n$ ) increases beyond 2 due to the expressibility limits of the ansatz. However, the outer layers (IVQSolver and GVQSolver) maintain near-100% success rates by shifting the burden to classical iterations. GVQSolver, in particular, confines quantum work to a fixed subspace (e.g., 2 qubits for a subspace dimension of 4), making the quantum cost independent of the total system size.
Condition Number: VQSolver performance degrades rapidly with increasing condition number ( $\kappa$ ). IVQSolver mitigates this up to $\kappa \approx 300$ , while GVQSolver extends tolerance to $\kappa \approx 1000$ . Enabling the inner preconditioner significantly improves success rates (e.g., from 15% to 80% at $\kappa=1000$ ) and reduces circuit counts by an order of magnitude.
Ansatz Parameters: The success of the base solver is strictly limited by the number of ansatz parameters relative to the state space dimension ( $2^n - 1$ ). The iterative outer layers compensate for insufficient ansatz expressibility, allowing accurate solutions even with minimal parameters.
Backend Execution: On real hardware ("cloud" backend), the majority of machine time is consumed by job submission, queuing, and retrieval rather than QPU execution time, especially at low shot counts. Increasing shot counts did not monotonically reduce the total number of circuits required, as sampling noise alters the optimization trajectory rather than just perturbing a fixed path.

Engineering Case Study: IEEE 118-Bus System

Setup: The solver was embedded in a classical Newton iteration to solve power flow equations. The Jacobian (order 181) was ill-conditioned ( $\kappa \approx 3.1 \times 10^3$ ).
Preconditioning Impact: The outer preconditioner reduced the condition number to $\approx 1.3 \times 10^2$ and padded the dimension to 256. This reduced the GMRES rounds required per Newton step from 2140 (unpreconditioned) to 7, a speedup factor of ~300 in rounds and ~650 in time.
Accuracy: The hybrid solution converged to the specified tolerance ( $10^{-6}$ p.u. power mismatch). The final solution reproduced the classical reference with a maximum voltage magnitude error of $2.3 \times 10^{-8}$ p.u. and a voltage angle error of $3.4 \times 10^{-6}$ degrees.
Resource Usage: The entire solve utilized only 2 qubits (due to the fixed subspace dimension) and 2492 circuits, demonstrating that the quantum resource consumption is decoupled from the problem size.

Significance and Claims

The paper claims that PyQLAS represents a shift from "algorithm demonstration" to "engineering component." Its significance lies in providing a deliberate division of labor where the quantum device is treated as a bounded resource for specific subroutines, while the classical host drives the overall solution process.

The authors emphasize that the library is not a fault-tolerant tool but a practical solution for near-term, noisy hardware. By validating the system on a real-world engineering problem (IEEE 118-bus) where the solver is embedded in a larger classical workflow, the paper demonstrates that quantum linear solvers can be integrated into existing simulation loops without requiring the application to be rewritten as a separate experiment. The results confirm that with appropriate hybrid organization (nested solvers and preconditioning), quantum linear solvers can achieve engineering-grade accuracy on real hardware while keeping quantum resource requirements fixed and manageable.