Papers
Topics
Authors
Recent
Search
2000 character limit reached

Linear Systems and Eigenvalue Problems: Open Questions from a Simons Workshop

Published 5 Feb 2026 in math.NA and cs.DS | (2602.05394v1)

Abstract: This document presents a series of open questions arising in matrix computations, i.e., the numerical solution of linear algebra problems. It is a result of working groups at the workshop \emph{Linear Systems and Eigenvalue Problems}, which was organized at the Simons Institute for the Theory of Computing program on \emph{Complexity and Linear Algebra} in Fall 2025. The complexity and numerical solution of linear algebra problems %in matrix computations and related fields is a crosscutting area between theoretical computer science and numerical analysis. The value of the particular problem formulations here is that they were produced via discussions between researchers from both groups. The open questions are organized in five categories: iterative solvers for linear systems, eigenvalue computation, low-rank approximation, randomized sketching, and other areas including tensors, quantum systems, and matrix functions.

Summary

  • The paper identifies key challenges in iterative solvers and eigenvalue methods, emphasizing the need for refined condition number and convergence analyses.
  • It rigorously examines multigrid convergence, preconditioning effects, and finite precision issues, bridging theoretical insights with practical computational challenges.
  • The workshop synopsis calls for novel approaches in randomized algorithms and low-rank approximations, advancing both numerical analysis and computational complexity.

Open Problems in Linear Systems and Eigenvalue Computation: A Simons Workshop Synopsis

Introduction

This document, "Linear Systems and Eigenvalue Problems: Open Questions from a Simons Workshop" (2602.05394), synthesizes a collection of precise, technically formulated open problems in numerical linear algebra and theoretical computer science. The covered domains—iterative solvers, eigenvalue computation, low-rank approximations, sketching, and emerging directions such as tensor methods and quantum systems—highlight both algorithmic frontiers and complex interactions between computation, precision, and structure. The problems reflect the need for closer synergy between numerical analysis and computational complexity communities, targeting both empirically relevant and theoretically tractable challenges.

Iterative Solvers for Linear Systems

Benchmark Design and Robust Scalability

A central theme is the lack of comprehensive benchmark families for linear system solvers that bridge theoretical and numerical communities. There is a strong call for software and model problems parameterized by physical and discretization properties, especially for PDE-induced systems such as highly anisotropic diffusion, advection-dominated phenomena, and indefinite Helmholtz problems. The challenges involve designing fast algorithms with nearly linear complexity, amenable to both theoretical guarantees and robust empirical performance.

Multigrid Methods and Algebraic Analysis

The document identifies the formal proof of optimal multigrid convergence for wide classes of polynomially bounded symmetric weakly-chained diagonally dominant M-matrices (SWCDDM) as a fundamental unresolved problem. Existing convergence proofs are primarily rooted in geometric settings and strong SDDM structure. Extending algebraic multigrid analysis, especially to broadband and non-Laplacian matrix classes, remains open, with potential impact on both the TCS and NLA communities.

Complexity and Spectral Structure

Critical attention is given to spectral distribution and its nuanced effect on iterative solver complexity. Notably, the document highlights that condition number alone can provide a poor complexity estimate in the presence of clustered or outlier singular values/eigenvalues. There are sharp distinctions between complexity in the direct access model (where entire matrix entries are available) versus the matrix-vector-product model, particularly for systems with outlying or clustered spectrum [derezinski2025approaching].

Key open problems include establishing the precise arithmetic and bit complexity for classes of (n,k,l,κ)(n, k, l, \kappa) matrices (with kk large, ll outlying singular values), and clarifying whether averaged condition numbers or alternate spectral summaries yield tighter bounds for convergence, including in finite precision.

Preconditioning and Non-Normality

The document challenges the widespread heuristic that preconditioning should focus solely on reducing condition number. Instead, it emphasizes the nuanced, sometimes non-monotonic relationship between spectrum, eigenvector conditioning, and iterative convergence—especially for nonsymmetric and highly nonnormal systems, where field-of-values or pseudospectral characteristics may be more indicative. There is a demand for more descriptive, perhaps problem-specific, convergence criteria for methods such as GMRES, with rigorous ties to eigenstructure and preconditioner effects.

Finite Precision and Residual Behavior

Several problems probe the finite-precision behavior of CG and Lanczos-type methods, including precise residual norm analysis, backward/forward stability, necessary bit precision, and distinctions among various implementations (plain versus block, and CG versus Lanczos). New stable or interpretable analyses—possibly using more abstract matrix perturbation models—are sought, as are characterizations for block methods in finite arithmetic.

The Forsythe Conjecture

An explicit challenge is posed by the classical Forsythe conjecture on the asymptotic cycling of restarted gradient-type methods. Despite numerical evidence and special-case results, the general conjecture remains unresolved, especially for restart lengths s>2s > 2.

Eigenvalue Computation

Randomization, Conditioning, and Derandomization

A major theoretical bottleneck concerns the need for random perturbations (pseudospectral shattering) in achieving polynomial condition numbers for Schur and diagonalization algorithms [Banks-et-al-23]. While randomized algorithms can ensure κeig(A+E)\kappa_{eig}(A+E) is polynomially bounded in n/δn/\delta with high probability, the existence of polynomial-time deterministic algorithms achieving similar guarantees is unknown. Derandomizing these regularization methods—via either explicit constructions or deterministic "shattering" matrices—constitutes a prominent open direction.

For Hermitian tridiagonal matrices, there is a related problem of constructing deterministic diagonal perturbations achieving spectral gaps analogous to the Minami bound.

Bit Complexity and Inversion-Free Diagonalization

Known randomized eigenvalue algorithms require bit precision growing as O(log4(n/δ)logn)O(\log^4(n/\delta)\log n) for backward stability. Improving this—ideally to the O(log(n/δ))O(\log(n/\delta)) bits attained in optimized Hermitian algorithms [shah2025hermitian]—remains an explicit open problem, with implications for both numerical practice and algorithmic optimality.

Ritz Values, Invariant Subspaces, and Arnoldi Process Analysis

Several open problems focus on the fidelity and localization of Ritz values—in both deterministic and probabilistic settings—when approximate or random subspaces are used. There is insufficient understanding of the distribution of Ritz values within the numerical range for non-Hermitian problems and the precise bounds on eigenvector conditioning in compressed scenarios.

Tridiagonal Eigenvalue Algorithms (MRRR)

Despite widespread use of the Multiple Relatively Robust Representations (MRRR) algorithm for tridiagonal eigenproblems, a complete TCS-style floating-point analysis guaranteeing correctness and convergence for all inputs is lacking. Extending or adapting MRRR to bidiagonal SVD problems—while retaining orthogonality, accuracy, and operation count—remains an ongoing challenge, especially in the presence of tight spectral clusters.

Spectral Radius and Rightmost Eigenvalues

The existence of gap-free algorithms for computing leading eigenvalues (magnitude and rightmost real part) of general nonnormal matrices, with polylogarithmic iteration complexity in nn and κV\kappa_V, is not yet demonstrated. Formalizing and improving the practical guarantees of power/inverse iteration methods, especially for defective or nearly defective matrices, is a highlighted gap.

Low-Rank Approximation and Column Subset Selection

Quasi-Optimal Algorithmic Guarantees

While greedy and randomized column selection algorithms (e.g., CPQR, GECP, and RRQR) function well empirically, theoretical guarantees often exhibit exponential dependencies on rank in the worst case, whereas observed behavior is substantially better. The challenge is to characterize structural (e.g., positivity, smoothness, diagonal dominance) or problem-dependent conditions under which quasi-optimal performance—such as polynomial or logarithmic factors in bounds—can be ensured.

Block, Row, and Partition Selection in Structured Matrices

For matrices with underlying geometric or physical structure (e.g., arising in hierarchical solvers, kernel learning, or PDE discretizations), efficient block or partition-adaptive low-rank approximations are essential. Open questions pertain to the existence and implementation of algorithms yielding near-optimal approximations for broad PDE families, and the optimal dependence of accuracy on partitioning parameters.

Laplacian Inverse and Submodularity

Recently, the submodularity of the nuclear norm Nyström approximation error for Laplacian inverses has been established, with immediate implications for Markov chain compression and graph reduction. Extending this result to SDDM, SDD, or less structured matrices could broaden the range of greedy and volume sampling-based methods with formal performance guarantees.

Volume Sampling Tightness

An explicit challenge is to quantify the tightness of volume sampling-based error bounds relative to worst-case optimal subset selection, particularly for trace/nuclear objectives and fixed spectrum cases. This impacts foundational sampling theory in low-rank matrix approximation.

Randomized Sketching and Embeddings

Subspace Injections Versus Embeddings

The subspace embedding (OSE) paradigm is often stricter than necessary for practical accuracy in sketched least squares, regression, and low-rank approximation. The more permissive subspace injection (OSI) property can enable sketch dimension or sparsity improvements, and open problems involve establishing when OSI suffices for relative-error bounds (not just constant-factor), including for p\ell_p problems and randomized SVD.

Sparse Embeddings: Optimality and Phase Transitions

The Nelson–Nguyen conjecture on optimal tradeoffs between dimension and sparsity for very sparse embeddings (e.g., SparseStack) is central. While recent breakthroughs reduced subpolylogarithmic gaps [chenakkod2026optimal], closing them fully and identifying exact thresholds for constant sparsity and dimensions remains unresolved. Empirical success at constant sparsity below established OSE barriers suggests that OSI-based analyses may unlock further progress [Tro25].

Fast Structured Transforms

The need for tight bounds for rerandomized structured transforms (e.g., two- or three-level randomized Hadamard transforms) is highlighted by both practical usage and empirical evidence for k=O(r)k=O(r). The theoretical picture is still evolving, especially for OSI properties and for multiple rounds of randomization in large-scale, GPU- or hardware-accelerated settings.

Tensors, Quantum Problems, and Matrix Functions

Tensor Train and Hierarchical Tensor Decompositions

Theoretical bounds for the approximation error of tree-based and tensor train decompositions are limited to those implied by sequential SVDs, typically with an (m1)ϵ(m-1)\epsilon bound for an mm-node tree. Whether strictly better polynomial algorithms exist, or whether this bound is tight under mild assumptions, is a significant open question. There are special cases (Tucker format), and randomized [amsel2025quasioptimalhierarchicallysemiseparablematrix] and structured [ceruti2025low] matrix analogs, but comprehensive analysis is missing.

Nonlinear Eigenvalue Problems from Quantum Systems

New NEPv instances motivated by quantum Hamiltonians—especially those with tensor product structure—pose the dual challenge of algorithmic scalability (iteration per dd factors in the system, not full dimension) and local superlinear convergence. Despite the existence of Newton-type methods [bai2018robust], the step complexity relative to system size and structure is open.

Matrix Sign Function with Matrix Multiplication Constraints

There is a renewed focus on approximating the matrix sign function using a fixed number of matrix-matrix multiplications, a critical building block in recursive eigensolvers, density matrix computation, and other high-performance contexts. Tight estimates for the minimal approximation error as a function of allowed matrix multiplications, structural properties (e.g., composition of low-degree polynomials), and connections to classical approximation theory are open.

Conclusion

This document articulates open problems at the interface of numerical linear algebra and theoretical computer science, emphasizing challenges at the algorithmic, structural, and complexity-theoretic levels. Progress on these issues will likely require new theoretical frameworks, advanced randomization/derandomization techniques, deeper understanding of matrix and operator structure, and attention to practicality in high-dimensional and hardware-oriented environments. The cross-disciplinary nature of these problems offers substantial avenues for breakthroughs in computational mathematics, data science, simulation, and emerging areas such as quantum and tensor computation.

Paper to Video (Beta)

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Explain it Like I'm 14

Overview: What this paper is about

This paper is a collection of open questions (problems people haven’t solved yet) about how to do big matrix calculations faster, more reliably, and with better theory. These calculations show up everywhere: in simulating physics (like heat, wind, or waves), in engineering, and in machine learning. The authors brought together two research communities—numerical analysis (people who build accurate algorithms) and theoretical computer science (people who prove strong speed guarantees)—to agree on important challenges they can tackle together.

The questions are grouped into five areas:

  • Solving linear systems (equations like Ax=bAx=b)
  • Finding eigenvalues (numbers that describe a matrix’s fundamental behavior)
  • Low-rank approximation (summarizing big data with fewer numbers)
  • Randomized sketching (speeding up work by cleverly compressing data)
  • Other topics (tensors, quantum systems, matrix functions)

This summary focuses most on the first area, since that’s where the provided text goes deepest.

Key questions in simple terms

The paper asks things like:

  • Can we create a shared set of “video game levels” (benchmarks) for testing solvers that reflect real-world problems and are fair for both communities?
  • Can we prove that multigrid methods (a popular fast solver) work quickly for much broader types of problems, not just the classic textbook ones?
  • When do newer randomized methods beat classic methods like Conjugate Gradient (CG)?
  • Why do a few unusual “outlier” values in a matrix (very big or very small ones) make solving much easier—or harder—than the “worst-case” condition number suggests?
  • How do practical issues like limited computer precision affect all of the above?

How they approach these questions

Think of a matrix as a huge, structured puzzle. The paper outlines approaches for testing and understanding solvers using realistic puzzle families and clear rules:

1) Build better benchmarks from real physics

The authors propose software that generates many versions of standard physics problems, each controlled by parameters (knobs you can turn) so researchers can test how solvers behave as problems get harder. Examples include:

  • Diffusion (like heat spreading): (a(x,y)u)=f-\nabla \cdot (a(x,y)\nabla u) = f
  • Convection–diffusion (heat spreading plus wind): add a “wind” term b(x,y)ub(x,y)\cdot\nabla u that makes the system nonsymmetric
  • Helmholtz (waves): 2uk2u=f-\nabla^2 u - k^2 u = f, which leads to “indefinite” systems that are trickier to solve

When you turn certain knobs (like making wind very strong or mixing in very different material properties), the matrices change in ways that challenge different algorithms.

2) Understand multigrid more broadly

Multigrid is like fixing a blurry photo by working at multiple zoom levels: smooth out the high-frequency errors, then correct the low-frequency ones on a coarser grid, and repeat. It’s famously fast for many problems. The paper asks for proofs that multigrid can be guaranteed fast on a bigger class of matrices that go beyond the textbook case (for example, certain diagonally dominant matrices that resemble physics problems but aren’t identical to them).

To do this, they focus on two key properties:

  • Smoothing: a step that quickly damps out “wiggly” errors
  • Approximation: a coarser problem that accurately captures the slow-to-fix errors

If both hold in general settings, multigrid should be fast in theory, not just in practice.

3) Compare CG vs. randomized “sketch-and-project”

  • Conjugate Gradient (CG) is a classic method that uses matrix–vector products to steadily improve the solution.
  • Randomized methods (like randomized coordinate descent or “sketch-and-project”) pick parts (rows/columns) of the matrix at random to make quick progress.

The paper asks: in which situations—based on how the matrix’s eigenvalues are arranged—does a randomized method reach a good answer faster (per equal “effort”) than CG?

4) Study the spectrum (the set of singular values/eigenvalues)

Not all matrices with the same “condition number” are equally hard. If most singular values are clustered together with a few “outliers” (very large or very small), some methods can solve the system much faster than the condition number suggests. The paper explores:

  • How outliers help or hurt different methods
  • “Averaged” condition numbers (think: using an average instead of worst-case) to better predict real difficulty
  • Differences between two computing models:
    • Direct access: you can work with the full matrix directly
    • Matrix–vector product only: you can only compute AxAx or AxA^\top x (common for very large, sparse problems)

5) Handle real-world computing limits

On real computers, numbers are stored with limited precision. Some methods are sensitive to this and can lose accuracy unless you use more precision (which costs time). The paper calls for careful analysis of how many bits/steps are truly needed to keep solutions reliable.

Main ideas and why they matter

Here are the takeaways, explained with everyday analogies:

  • Shared benchmarks are like a fair obstacle course: If everyone tests on the same well-designed levels (diffusion, convection–diffusion, Helmholtz), we can compare methods honestly, discover weaknesses, and improve faster.
  • Multigrid beyond the classics: Multigrid is like a superfast cleanup crew that works at different zoom levels. Proving it works for more general “messy rooms” (matrix classes) means we could guarantee speed for many real problems, not just the clean, ideal ones.
  • CG vs. randomized methods: CG steadily marches downhill on a landscape. Randomized methods sample a few directions and jump. Depending on the landscape (the eigenvalue distribution), jumping can be faster. The paper aims to map out where each approach wins.
  • Outliers change the game: Imagine most piano keys are tuned together, but a few are very high or very low. Those few keys (outliers) can make certain songs (solvers) much easier or harder to play. Looking at averages, not just the single worst key, often predicts difficulty better. This can lead to faster algorithms in practice.
  • Dense vs. sparse, and access models: If the matrix is dense and you can touch all of it, some clever randomized tricks can be surprisingly fast. If it’s sparse and huge, you usually can only do AxAx quickly; then Krylov methods (like CG) can shine. The paper clarifies where each model gives the edge.
  • Precision matters: Some fast methods may stumble when numbers are rounded on real machines. Understanding the “bit complexity” helps us build versions that stay accurate without becoming slow.

What could this change?

If these open questions get answered, we could:

  • Build faster, more reliable solvers for physics simulations (climate, aerodynamics, waves), engineering design, and large-scale machine learning.
  • Create benchmark suites that speed up progress across communities by making comparisons fair and meaningful.
  • Understand when to choose CG, when to choose a randomized method, and how to precondition (set up) problems for the best performance.
  • Move beyond worst-case thinking (plain condition number) to smarter measures that better match real-world difficulty.
  • Ensure algorithms are not just fast in theory, but stable and accurate on actual computers.

In short: this paper sets a roadmap for combining smart theory with practical algorithm design, so that solving huge linear algebra problems becomes faster, more predictable, and more useful across science and technology.

Knowledge Gaps

Below is a consolidated list of concrete knowledge gaps, limitations, and open questions left unresolved in the paper. Each point highlights missing theory, absent benchmarks, or unclear algorithmic behavior that future work could directly target.

  • Standardized benchmark generation: No agreed-upon, parameterized software pipeline exists to synthesize PDE-based linear systems (with reproducible meshes, boundary conditions, right-hand sides, and ground-truth targets) that systematically cover key regimes (e.g., anisotropy, variable coefficients, large jumps, irregular meshes, higher-order discretizations with positive off-diagonals, and a range of Péclet numbers).
  • Robust near-linear solvers across parameter ranges: For each proposed benchmark class (diffusion with large coefficient jumps; convection–diffusion on structured/unstructured meshes; higher-order discretizations with positive off-diagonals), there are no proven near-linear-time algorithms whose iteration counts and constants are uniform across the full parameter ranges and that deliver accuracy commensurate with the discretization error (e.g., O(h2)O(h^2) in the same norm).
  • Nonsymmetric convection–diffusion analysis: Lacking are rigorous convergence guarantees for GMRES or alternative iterations on nonsymmetric discretizations that account for eigenvector conditioning, upwinding/stabilization choices, and non-alignment of advection with the grid; there is no TCS-style analysis framework that yields parameter-robust rates for these cases.
  • Helmholtz (indefinite) solvers: There are no provable, near-linear-work solvers for the discrete Helmholtz problem with shifted-Laplacian preconditioning; missing are prescriptions for choosing complex shifts (α,β)(\alpha, \beta) with guarantees on spectrum separation, iteration counts uniform in wavenumber kk and mesh size, treatment of sequences of kk values, and a finite-precision analysis for complex preconditioned systems.
  • Algebraic multigrid (AMG) for SWCDDM matrices: It is open to prove that, for polynomially bounded symmetric weakly-chained diagonally dominant M-matrices, AMG can (i) be set up in O~(nnz(M))\tilde O(\mathrm{nnz}(M)) time, (ii) apply an implicit preconditioner ZZ in O(nnz(M))O(\mathrm{nnz}(M)) time, and (iii) achieve spectral bounds Ω(1)M1ZO(1)M1\Omega(1) M^{-1} \preceq Z \preceq O(1) M^{-1} with constants independent of nn; the exact smoothers and prolongation/restriction constructions that guarantee smoothing and approximation properties in this algebraic class remain unidentified.
  • Variants and limits of AMG guarantees: Even restricted to planar matrices, or with stricter setup/apply time budgets (e.g., O(nnz(M)poly(loglognnz))O(\mathrm{nnz}(M)\,\mathrm{poly}(\log\log \mathrm{nnz}))), no proofs exist; it is also unknown how far the SWCDDM requirement (nonpositive off-diagonals, weak chaining) can be relaxed (e.g., to SDD matrices with some positive off-diagonals) without losing guarantees.
  • Bridging multigrid theory and TCS: There is no general method to certify the smoothing and approximation properties for algebraically defined hierarchies (without PDE geometry), including quantitative constants independent of nn, for the proposed matrix classes.
  • CG vs. randomized coordinate descent (RCD): It remains unresolved to characterize eigenvalue conditions under which a sketch-and-project method (e.g., RCD) beats unpreconditioned conjugate gradient in epoch complexity; specifically, the stylized model with Haar-random eigenvectors and polynomially decaying eigenvalues lacks asymptotic results for TCGT_{\mathrm{CG}} vs. TRCDT_{\mathrm{RCD}} as nn\to\infty, including dependence on decay rate pp and tolerance ε\varepsilon.
  • Fair comparison under enhancements: The impact of preconditioning, block/mini-batch updates, momentum, and importance sampling on CG vs. sketch-and-project comparisons is unquantified; a common “epoch” accounting and matching of per-epoch computational cost remains to be formalized.
  • Sparse direct-access algorithms for large outliers: For (n,k,0,κ)(n,k,0,\kappa) systems (large top singular values), it is unknown whether one can achieve O~(kω+nnz(A)κ)\tilde O(k^\omega + \mathrm{nnz}(A)\,\kappa) arithmetic operations to high accuracy, matching the dense direct-access bounds in a sparsity-aware regime.
  • Averaged condition-number regime in sparse settings: The smallest p>0p>0 for which solving Ax=bAx=b in O~(TAκˉp)\tilde O(\mathcal{T}_A\cdot \bar\kappa_p) time holds (with TA=nnz(A)\mathcal{T}_A=\mathrm{nnz}(A)) is unknown; current guarantees for dense time (TA=n2\mathcal{T}_A=n^2) with p>1/2p>1/2 (general) and p>1/4p>1/4 (PSD) have no sparse analogs, and lower bounds linking this question to Schatten-pp norm estimation are incomplete.
  • Algorithms for small outliers: The complexity of solving (n,0,l,κ)(n,0,l,\kappa) systems (small bottom singular values) remains poorly understood in both the matrix–vector product and direct-access models; it is unclear whether direct-access can break the O~(lκ)\tilde O(l\,\kappa) iteration barrier or achieve better dependence on ll and κ\kappa than Krylov methods, and what lower bounds apply.
  • Random dense linear systems: For AA with i.i.d. Gaussian/Rademacher/Bernoulli entries, it is open whether one can, with high probability, solve Ax=bAx=b faster than O(nω)O(n^\omega) (even with classical ω=3\omega=3), and whether there are matching lower bounds on the number of matrix–vector products (e.g., Ω(n)\Omega(n)).
  • Finite precision and stability for outlier-structured systems: The bit complexity (Word-RAM model) and backward/forward stability of solvers for (n,k,l,κ)(n,k,l,\kappa) systems are not established; in particular, it is unknown whether the dense direct-access O~(kω+n2κ)\tilde O(k^\omega + n^2\,\kappa) running time for (n,k,0,κ)(n,k,0,\kappa) extends under finite precision, what precision growth per iteration is required for Krylov methods with significant outliers, and how randomized sketching pipelines can be made provably backward stable.
  • Practical stopping and accuracy criteria: There is no standardized protocol to ensure iterative solvers stop when the algebraic error matches the discretization error (e.g., O(h2)O(h^2)) in a prescribed norm across proposed benchmarks; mapping from residual norms to discretization-consistent error bounds remains unspecified.
  • Benchmark evaluation and baselines: While BoomerAMG, GENEO/HPDDM, and IFISS are suggested baselines, their theoretical coverage for the proposed parameterized classes (e.g., with strong nonsymmetry, large jumps, higher-order stencils with positive off-diagonals, and indefinite Helmholtz) is not established; agreed-upon performance metrics (iteration counts, operator complexity, setup/apply times, memory growth) and reproducibility practices are missing.
  • Extending Laplacian-based TCS techniques: How to adapt graph-Laplacian and SDDM-centric TCS techniques to discretizations with positive off-diagonals, pronounced nonsymmetry, or indefiniteness is unaddressed; concrete reductions or structural surrogates enabling TCS-style guarantees for these broader classes are lacking.

Glossary

  • Algebraic Multigrid (AMG): A multilevel method that builds coarse representations directly from the matrix to accelerate solving large sparse linear systems. "Algebraic Multigrid runs in time O~(nnz(M))\tilde{O}(\operatorname{nnz}(\mathbf{M}))"
  • approximation property: A condition in multigrid theory ensuring the coarse-grid correction accurately represents low-frequency error components. "Approximation Property: The interpolation operator PP and the restriction operator RR satisfy the approximation property"
  • Averaged condition numbers: Measures of conditioning based on averages of singular value ratios, offering finer complexity characterizations than the worst-case condition number. "Averaged condition numbers."
  • bidiagonal matrices: Matrices with nonzeros only on the main diagonal and either the super- or sub-diagonal, important in singular value computations. "and singular values of bidiagonal matrices."
  • BoomerAMG multigrid method: A widely used algebraic multigrid solver from the hypre library for large sparse systems, especially from PDEs. "the BoomerAMG multigrid method"
  • column subset selection: Choosing a subset of columns to form a low-rank approximation of a matrix. "A number of questions specifically concern low-rank approximation by column subset selection."
  • conjugate gradient (CG): A Krylov subspace method for solving symmetric positive definite linear systems efficiently. "the multigrid method, conjugate gradient, and the generalized minimum residual method (GMRES)."
  • coarse grid correction operator: The operation in multigrid that projects errors to a coarser level, solves there, and corrects the fine-grid solution. "and a coarse grid correction operator."
  • Convection-diffusion PDEs: Partial differential equations combining diffusion and advective transport, often leading to nonsymmetric discrete systems. "Convection-diffusion PDEs give rise to nonsymmetric systems of equations."
  • Dirichlet conditions: Boundary conditions specifying the value of a function on the boundary of the domain. "zero Dirichlet conditions"
  • eigenvector-dependent nonlinear eigenvalue problems: Problems where the operator depends on the eigenvector, common in quantum chemistry models. "eigenvector-dependent nonlinear eigenvalue problems"
  • finite differences: A discretization technique that approximates derivatives with differences on a grid. "Finite difference and finite element discretizations of this PDE lead to linear systems of equations."
  • finite element discretizations: A method that approximates PDE solutions using basis functions over elements of a mesh. "Finite difference and finite element discretizations of this PDE lead to linear systems of equations."
  • GENEO preconditioner: A domain decomposition preconditioner based on Generalized Eigenproblems in the Overlap. "the GENEO preconditioner with its implementation in the HPDDM library"
  • GMRES (generalized minimum residual method): A Krylov method for nonsymmetric systems that minimizes the residual over a growing Krylov subspace. "the multigrid method, conjugate gradient, and the generalized minimum residual method (GMRES)."
  • graph Laplacians: Matrices representing the combinatorial Laplacian of a graph; central to many scalable solvers. "graph Laplacians that have been a focus of TCS research in linear system solvers."
  • Haar unitary: A unitary matrix distributed uniformly with respect to Haar measure on the unitary group. "UCn×n is Haar unitary\mathbf{U} \in \mathbb{C}^{n \times n} \text{ is Haar unitary}"
  • Helmholtz equation: A PDE modeling wave phenomena; its discretizations yield challenging indefinite linear systems. "Helmholtz equation."
  • IFISS: A MATLAB package for finite element-based test problems in incompressible flow and related PDEs. "the associated library IFISS"
  • injections (in subspace embeddings): Weaker randomized linear maps than subspace embeddings that still suffice for certain approximation tasks with smaller sketch sizes. "the study of injections, which satisfy looser properties than the standard notion of randomized subspace embeddings."
  • Jacobi (smoother): An iterative relaxation method used as a smoother in multigrid, updating each variable based on diagonal scaling. "Gauss--Seidel or Jacobi"
  • Krylov subspace methods: Iterative solvers that build solutions in spaces spanned by successive matrix–vector products. "Krylov subspace methods such as the conjugate gradient method are not available."
  • low-rank approximation: Approximating a matrix by one of lower rank to reduce complexity while preserving structure. "Low-rank approximation is another pillar of numerical linear algebra"
  • LSQR: An iterative algorithm for solving sparse linear equations and least squares, equivalent to CG on the normal equations. "equivalently, convergence of LSQR for general systems"
  • LU with complete pivoting: A variant of LU factorization that selects pivots by searching the entire remaining submatrix to ensure numerical stability. "LU with complete pivoting"
  • M-matrices: A class of matrices with nonpositive off-diagonals and properties ensuring stability and monotonicity, common in discretized PDEs. "symmetric diagonally dominant M-matrices (SDDM matrices)"
  • multigrid V-cycle: A multigrid traversal pattern that descends through coarser grids and ascends back to the finest grid to correct errors. "the multigrid V-cycle for multiple levels"
  • nonsymmetric systems (of equations): Linear systems whose coefficient matrices are not symmetric, often arising from convection-diffusion discretizations. "nonsymmetric systems of equations"
  • planar matrices: Matrices corresponding to planar graphs, often enabling specialized algorithmic analyses. "for planar matrices."
  • prolongation (interpolation): The operator that maps corrections from a coarser grid to a finer grid in multigrid methods. "a smoother, prolongation (interpolation) and restriction operators"
  • QR iteration: An eigenvalue algorithm that applies successive QR factorizations to converge to Schur form. "a provably convergent variant of QR iteration for general matrices"
  • QR with column pivoting: A QR factorization variant that reorders columns to improve numerical stability and rank-revealing properties. "QR with column pivoting"
  • Randomized coordinate descent: A sketch-and-project/optimization method that updates one coordinate at a time chosen randomly. "Randomized coordinate descent"
  • randomized embeddings: Random linear maps used to compress data while preserving structure for downstream computations. "studies the properties of randomized embeddings"
  • randomized sketching: Techniques that compress matrices via random projections to accelerate computations. "randomized sketching"
  • Rademacher (entries): Random variables taking values ±1 with equal probability, used in random matrix models. "Rademacher, or Bernoulli"
  • restriction operators: Operators that transfer residuals or vectors from fine to coarse grids in multigrid. "a smoother, prolongation (interpolation) and restriction operators"
  • Ritz values: Approximations to eigenvalues obtained from projections onto Krylov subspaces. "questions related to understanding of the convergence of Krylov methods (distribution of Ritz values)."
  • Schatten pp-norm estimation: Estimating matrix norms defined by pp-norms of singular values, relevant to sketching complexity analyses. "Schatten pp-norm estimation"
  • SDD matrices (symmetric diagonally dominant): Symmetric matrices where each diagonal entry is at least the sum of absolute off-diagonal entries in its row. "symmetric diagonally dominant (SDD) matrices"
  • SDDM matrices: Symmetric diagonally dominant M-matrices with nonpositive off-diagonals, commonly linked to graph Laplacians. "symmetric diagonally dominant M-matrices (SDDM matrices)"
  • shifted Laplacian preconditioner: A complex-shifted Laplacian used to precondition indefinite Helmholtz problems. "A well-developed approach for solving the discrete equations efficiently is to use a {\em shifted Laplacian preconditioner}"
  • smoothing property: A multigrid condition asserting that the smoother reduces high-frequency error components effectively. "Smoothing Property"
  • subsampled randomized Hadamard transforms: Structured random projections using subsampled Hadamard matrices for fast embeddings. "subsampled randomized Hadamard transforms"
  • SuiteSparse collection: A curated repository of sparse matrices for benchmarking and research. "SuiteSparse collection"
  • symmetric positive definite (SPD): Matrices that are symmetric with all positive eigenvalues, ensuring well-posedness for CG. "symmetric positive definite"
  • tridiagonal matrices: Matrices with nonzeros only on the main diagonal and immediate off-diagonals, central in eigenvalue algorithms. "eigenvalues of tridiagonal matrices"
  • two-grid method: The simplest multigrid algorithm using one fine and one coarse grid to reduce errors. "Define a two-grid method that satisfies:"
  • upwind differencing: A discretization strategy for convection terms that enhances stability by biasing differences in the flow direction. "when using upwind differencing"
  • weakly diagonally dominant: Rows where the diagonal equals the sum of absolute off-diagonal entries, important in stability analyses. "A row ii of M\mathbf{M} is weakly diagonally dominant"
  • SWCDDM matrices: Symmetric weakly-chained diagonally dominant M-matrices where weak rows connect to strict ones via nonzero entries. "polynomially bounded SWCDDM matrices"
  • Word-RAM model: A computational model measuring bit complexity with fixed-word arithmetic operations. "the Word-RAM model"
  • Real-RAM model: An idealized model assuming exact real arithmetic with unit-cost operations. "the Real-RAM model"

Practical Applications

Immediate Applications

The following items translate the paper’s open questions into concrete, deployable actions that practitioners can take now, along with sectors, potential tools/workflows, and key assumptions or dependencies.

  • Benchmark generator for PDE-derived linear systems (software, HPC, academia)
    • Description: Build and share a parameterized benchmark suite for diffusion, convection–diffusion, and Helmholtz model problems with tunable difficulty (e.g., coefficient jumps, advection strength, wave number k), yielding families of sparse matrices representative of real workloads.
    • Potential tools/products/workflows: “PDEBench-LS” open-source generator; CI-ready datasets and leaderboards; baseline integrations with BoomerAMG and HPDDM; wrappers for PETSc/Trilinos and SuiteSparse.
    • Assumptions/dependencies: Agreement on canonical parameter ranges and discretizations; availability of IFISS-like reference implementations; standardized accuracy targets (e.g., to discretization error).
  • Solver evaluation through spectrum-aware diagnostics (software, ML/AI, academia)
    • Description: Incorporate quick spectral-proxy checks (e.g., estimates of condition number, averaged condition numbers, detection of outliers via short Lanczos runs or Hutch++-style sketches) into solver pipelines to decide between CG, GMRES, coordinate-descent/Kaczmarz, or sketch-and-project methods.
    • Potential tools/products/workflows: “SpecScan” library/plugin that estimates cluster/outlier structure and recommends solver/preconditioner; auto-tuning hooks in PETSc/Trilinos.
    • Assumptions/dependencies: Reliable, low-cost spectral estimation; problem classes with clustered spectra; tolerance targets tied to discretization error.
  • Practical deflation for large outlying singular values (engineering/CFD, ML/analytics, robotics/SLAM)
    • Description: Use deflation/low-rank preconditioners to remove the dominant subspace (top-k singular/eigen directions) before applying CG/LSQR or sketch-and-project, improving convergence when data have strong low-rank structure.
    • Potential tools/products/workflows: “Deflate-k” preconditioner modules; block-Lanczos-based subspace extraction; integration with ridge-regression and Gauss–Newton pipelines.
    • Assumptions/dependencies: Existence of clear spectral outliers; stable subspace estimation in finite precision; amortization across repeated solves.
  • Stabilized advection discretizations to preserve solver-friendly structure (engineering/CFD)
    • Description: Use upwind schemes to retain diagonal dominance in convection–diffusion discretizations, improving multigrid and Krylov performance; standardize these choices in solver templates.
    • Potential tools/products/workflows: CFD mesh/discretization tool presets; automatic upwind switching based on local Peclet number; BoomerAMG/HPDDM-ready operators.
    • Assumptions/dependencies: Problem physics compatible with upwind stabilization; consistency with target accuracy (e.g., O(h2)).
  • Shifted-Laplacian preconditioning for Helmholtz (energy/seismic imaging, acoustics, healthcare/ultrasound)
    • Description: Apply complex shifted-Laplacian preconditioners with incomplete factors to accelerate iterative solvers for Helmholtz problems across multiple wavenumbers.
    • Potential tools/products/workflows: “HelmholtzShift” preconditioner plugin; tuning recipes for (α, β) shift parameters; batched multi-k workflows for parameter sweeps.
    • Assumptions/dependencies: Access to robust incomplete factorization; problem-specific tuning of shift; handling of complex arithmetic.
  • Averaged condition numbers to guide sketch sizes and stopping criteria (ML/analytics, finance, software)
    • Description: Use averaged condition numbers (e.g., p-averaged metrics) as practical proxies to set sketch sizes, choose embeddings, or inform adaptive stopping for least-squares/regularized problems.
    • Potential tools/products/workflows: “AvgKappa” module for estimating p-averaged metrics; integration with randomized least squares (e.g., SRHT, leverage sampling).
    • Assumptions/dependencies: Fast, reliable estimation of averaged metrics; regime where averaged metrics are much smaller than worst-case κ.
  • Coordinate-descent/Kaczmarz as memory-friendly solvers for SPD systems (robotics/SLAM, embedded/edge, networks)
    • Description: Use randomized coordinate/Kaczmarz solvers in memory- or bandwidth-constrained settings where cheap coordinate updates per epoch outperform global matvecs (especially for diagonally dominant SPD systems).
    • Potential tools/products/workflows: “RCD-epoch” kernels optimized for sparse rows; asynchronous/parallel updates; warm-starting across time steps.
    • Assumptions/dependencies: Favorable sparsity and cache locality; diagonal dominance or good sampling probabilities; acceptance of stochastic convergence variability.
  • Reproducible education and procurement benchmarks (academia, policy, public-sector HPC)
    • Description: Adopt parameterized PDE and linear-system benchmarks in courseware and public procurement evaluations to ensure apples-to-apples comparisons of solvers at target accuracies.
    • Potential tools/products/workflows: Curriculum modules; published evaluation protocols; leaderboards with fixed seeds and configurations.
    • Assumptions/dependencies: Community consensus on benchmark definitions; transparent hardware disclosures and runtime measurement practices.

Long-Term Applications

These opportunities require further research, scaling, or development, often contingent on resolving the paper’s open questions.

  • Near-linear-time algebraic multigrid with guarantees for SWCDDM matrices (energy, climate, chip EDA, networks)
    • Description: A provably near-linear AMG (with uniform constants) for polynomially bounded SWCDDM classes would deliver black-box optimal solvers for a wide array of PDE- and graph-derived systems.
    • Potential tools/products/workflows: “AMG-Prove” library with certified preconditioners; automated smoother/interpolator selection; deployment in PETSc/Trilinos.
    • Assumptions/dependencies: Proofs of smoothing and approximation properties on broad classes; robustness in finite precision; scalable parallel implementations.
  • Scalable solvers for nonsymmetric and indefinite systems (convection–diffusion, Helmholtz) with near-linear complexity (energy/seismic, acoustics, aero)
    • Description: Algorithms with theoretical and practical guarantees for nonsymmetric and indefinite problems would accelerate seismic inversion, radar/sonar, aeroacoustics, and metamaterial design.
    • Potential tools/products/workflows: New stationary iterations and preconditioners with analysis; multi-k pipelines; GPU-friendly complex arithmetic kernels.
    • Assumptions/dependencies: Theoretical convergence under realistic discretizations and boundary conditions; stable parameter choices; multi-level preconditioning in practice.
  • Hybrid direct+randomized solvers achieving O(kω + nnz(A)·κ)-type complexity (ML/analytics, software, finance)
    • Description: If direct-access randomized sketching matches near-optimal complexity on sparse/dense problems and extends to Word-RAM bit complexity, it would transform large-scale regression, graph Laplacians, and ridge problems.
    • Potential tools/products/workflows: “RandSolve” hybrid pipelines (deflation + sketch + iterative refinement); integration into scikit-learn/Spark; out-of-core variants.
    • Assumptions/dependencies: Practical detection of outlying singular values; stable randomized sketches; dependence on fast matrix multiplication exponent ω and finite precision stability.
  • Automated solver autotuning from spectral profiles (software, HPC)
    • Description: Predict solver/precoditioner performance from coarse spectral summaries (clusters/outliers, averaged κ) and auto-select methods to minimize time-to-solution under accuracy and hardware constraints.
    • Potential tools/products/workflows: “AutoSolver” service integrated with PETSc/Trilinos; reinforcement-learning controllers using spectral features; cloud/HPC autotuning dashboards.
    • Assumptions/dependencies: Fast, low-noise feature extraction; generalizable performance models; robust fallbacks for mispredictions.
  • Finite-precision-robust Krylov and sketching algorithms with bit-complexity guarantees (finance/risk, safety-critical CAE, cloud)
    • Description: New analyses and implementations that retain theoretical gains under realistic word sizes and ensure backward stability will broaden adoption in regulated or safety-critical applications.
    • Potential tools/products/workflows: Mixed-precision pipelines with error tracking; certified residual bounds; reproducible deterministic modes for auditability.
    • Assumptions/dependencies: Tight bit-complexity bounds for Krylov/deflation/sketching; hardware support for mixed precision; cost of precision scaling.
  • Faster algorithms for small-outlier regimes and random dense systems (communications, compressed sensing, ML theory)
    • Description: Solvers that exploit bottom-spectrum structure (small outliers) or random-matrix statistics to beat O(nω) in practice/theory could redefine baselines for random or ill-conditioned dense systems.
    • Potential tools/products/workflows: “RandomSys” solvers with model-based preconditioners; statistical certification of convergence; batched solvers for ensembles.
    • Assumptions/dependencies: New theory for small-outlier exploitation; stable preconditioners; applicability beyond idealized random models.
  • Expanded embeddings/injections for broader numerical tasks (software analytics, ML, scientific computing)
    • Description: Generalized randomized injections and structured embeddings (e.g., SRHT variants) tuned for new tasks (e.g., preconditioning, eigensolvers, PDE residual evaluation).
    • Potential tools/products/workflows: “EmbeddingKit” with task-specific embeddings; heuristics for optimal sparsity/structure; integration into least-squares and model-reduction workflows.
    • Assumptions/dependencies: Characterization of optimal sparse/structured embeddings; bounds that translate to practical speedups; numerical stability under streaming/online updates.
  • Tensor decompositions with provable error guarantees (recommenders, neuroimaging, chemometrics)
    • Description: Algorithms with worst-case error bounds for general tensors would unlock reliable, automated factorization in high-stakes applications.
    • Potential tools/products/workflows: “TensorProof” library; certified CP/Tucker decompositions; pipelines for multiway data with confidence intervals.
    • Assumptions/dependencies: New approximation theory; scalable implementations; sensitivity analyses under noise and missing data.
  • Deterministic eigenvalue algorithms with robust guarantees (aerospace, nuclear, structural simulation)
    • Description: Derandomized variants of effective randomized eigenvalue methods would provide predictable behavior and certifiable outcomes for safety-critical simulations.
    • Potential tools/products/workflows: Deterministic perturbation schedules; “SafeQR/SafeEV” routines with bounded spectra spread; integration with tridiagonal/bidiagonal specialists.
    • Assumptions/dependencies: Constructive derandomization achieving similar spectral “mixing”; backward stability; compatibility with existing reduction stages.
  • Matrix-function evaluation via few matmul operations (AI/Graph ML, control/MPC, signal processing)
    • Description: Characterize and exploit classes of matrix functions computable with a fixed number of matmuls to accelerate graph filters, kernel approximations, and control policies.
    • Potential tools/products/workflows: “FastMatFun” kernels for common filters (e.g., heat kernel, resolvents); differentiable implementations for deep learning; control toolchain plugins.
    • Assumptions/dependencies: Approximation error characterizations; interplay with sparsity and graph structure; GPU-optimized matmul backends.
  • Standardized certification frameworks for numerical solvers (policy, public-sector HPC, industry consortia)
    • Description: Use the proposed benchmark classes and accuracy targets to define certification standards for solver performance and reproducibility in procurement and funded research.
    • Potential tools/products/workflows: Open scorecards and test harnesses; versioned benchmark corpora with metadata; FAIR-compliant result repositories.
    • Assumptions/dependencies: Community/government buy-in; well-defined acceptance thresholds (e.g., time-to-discretization-error); transparent reporting practices.

These applications collectively map the paper’s open questions to actionable paths for tool-building, operational improvements, and future products, while noting the critical assumptions (matrix classes, spectral structure, precision, hardware) that influence feasibility and impact.

Collections

Sign up for free to add this paper to one or more collections.

Tweets

Sign up for free to view the 2 tweets with 112 likes about this paper.