quantum-linear-system-residual - SKILL.md Agent Skill

name: quantum-linear-system-residual description: "Residual-based quantum linear system algorithm with dynamic stopping methodology. Use when solving linear systems Ax=b on quantum computers, implementing HHL-type algorithms, quantum PDE solvers, or designing efficient quantum algorithms with adaptive precision control."

Quantum Linear System Solver with Residual-Based Dynamic Stopping

A quantum linear system algorithm (QLSA) that uses residual-based error estimation with dynamic stopping criteria, applied to elliptic partial differential equations.

Metadata

Source: arXiv:2605.06414
Authors: Xiantao Li
Published: 2026-05-07
Categories: quant-ph

Core Methodology

Key Innovation

Introduces a residual-based approach for estimating solution quality in quantum linear system algorithms, enabling dynamic stopping when sufficient precision is achieved without over-computing. Applied to elliptic PDEs, demonstrating practical advantage for scientific computing applications.

Technical Framework

Step 1: Problem Formulation

Given linear system Ax = b where A is an N×N Hermitian matrix:

Encode b as quantum state |b⟩
Goal: prepare |x⟩ = A^{-1}|b⟩ / ||A^{-1}|b⟩||

Step 2: Residual Estimation

Instead of fixed iteration count, compute the residual:

r_k = b - Ax_k

Estimate ||r_k|| using quantum amplitude estimation:

Prepare state |r_k⟩ using oracle queries
Use amplitude estimation to estimate norm
Stop when ||r_k|| / ||b|| < ε (target precision)

Step 3: Dynamic Stopping Criterion

while estimated_residual > tolerance:
    perform_one_qsvt_iteration()
    update_residual_estimate()

Step 4: QSVT Implementation

Using Quantum Singular Value Transformation (QSVT):

Construct polynomial approximation of 1/x
Apply block-encoding of A
Use phase estimation for eigenvalue filtering
Dynamic stopping adapts polynomial degree to needed precision

Step 5: Application to Elliptic PDEs

Discretize PDE to obtain linear system
Apply residual-based QLSA
Complexity scales polylogarithmically in condition number

Implementation Guide

Prerequisites

Qiskit, Pennylane, or equivalent quantum SDK
Block encoding of the system matrix A
State preparation oracle for |b⟩

Step-by-Step

Block-encode the matrix A using quantum circuits
Prepare the initial state |b⟩ using state preparation circuits
Construct QSVT polynomial for matrix inversion
Implement residual estimation circuit
Run adaptive iterations with dynamic stopping
Measure solution properties from final quantum state

Code Example (Conceptual)

from qiskit import QuantumCircuit
from qiskit.circuit.library import QSVT
import numpy as np

def residual_based_qsvt(block_encode_a, state_b, tolerance=1e-3):
    """Residual-based QSVT for linear system solving."""
    max_iterations = 100
    for k in range(max_iterations):
        # Apply QSVT step
        circuit = QSVT(block_encode_a, polynomial_degree=k)
        
        # Estimate residual using amplitude estimation
        residual_norm = estimate_residual(circuit, state_b)
        
        if residual_norm < tolerance:
            print(f"Converged at iteration {k}")
            return circuit
        
    return circuit

def estimate_residual(circuit, state_b):
    """Estimate residual norm using amplitude estimation."""
    # Prepare |r⟩ = |b⟩ - A|x_k⟩
    # Use Hadamard test or amplitude estimation
    # Returns ||r|| / ||b||
    pass

Applications

Scientific computing: Solving discretized PDEs on quantum computers
Financial modeling: Portfolio optimization via linear systems
Machine learning: Quantum linear regression, kernel methods
Engineering: Finite element analysis on quantum hardware

Pitfalls

Residual estimation requires additional quantum resources (ancilla qubits)
Block encoding of large matrices can be expensive
Dynamic stopping overhead must be balanced against fixed-iteration approaches
Condition number of A critically affects convergence speed
Current implementations assume fault-tolerant quantum hardware

Related Skills

quantum-circuit-builder
quantum-distributed-snapshot
quantum-tensor-network-ml