Pith. sign in

REVIEW 4 major objections 6 minor 1 cited by

The paper presents a blackbox direct solver for strong-admissibility H2 matrices that factors and solves dense structured systems in linear time and linear memory, demonstrated on systems up to one million unknowns.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-04 16:59 UTC pith:VY6TJBLH

load-bearing objection Solid engineering paper with honest experiments, but the 'Linear Complexity' title outruns the bounded-rank assumption the authors themselves flag as a sweet spot. the 4 major comments →

arxiv 2509.11152 v1 pith:VY6TJBLH submitted 2025-09-14 cs.DC

Linear Complexity mathcal{H}² Direct Solver for Fine-Grained Parallel Architectures

Wajih Boukaram , David Keyes , Sherry Li , Yang Liu , George Turkiyyah This is my paper
classification cs.DC MSC 65F0565F3065Y05
keywords H2 matricesdirect linear solverstrong admissibilityrecursive skeletonizationlinear complexityhierarchical low-rank matricesparallel computationbackward error
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper aims to establish that strong-admissibility H2 matrices—dense structured matrices whose far-field interactions are compressed into nested low-rank bases—can be factored and solved by a direct, non-iterative solver in time and memory that scale linearly with the number of unknowns. On four families of dense systems, including covariance matrices, Laplace and Helmholtz integral operators, and a global low-rank update, it reports factorization and solve timings and memory usage that track the linear reference lines up to 2^20 unknowns, with backward error controlled by the chosen truncation thresholds. The practical payoff would be a robust direct solver for large dense systems from integral equations, Gaussian processes, and related applications, designed for the batched, fine-grained parallelism of GPUs and many-core CPUs.

Core claim

The central claim is that recursive skeletonization, specialized to the strong-admissibility H2 format, yields a factorization expressed as a product of block unit-triangular factors and orthogonal projections, and that both factorization and solve execute in strictly linear time and memory. The algorithm augments the nested cluster bases on the fly with a QR-based basis for the fill-in produced by Schur complement updates, so that fill-in blocks remain admissible and are skeletonized together with the original admissible blocks. The measured complexity is O(Csp^2 k^3 n) for factorization and O(Csp k^2 n) for the solve, which is linear in n whenever the numerical rank k and the sparsity cons

What carries the argument

The key machinery is the strong-admissibility H2 format, where admissible blocks share nested basis matrices and small coupling matrices, combined with a fill-in matrix F that is processed together with the admissible part H. On each cluster, the algorithm (i) forms an augmented orthogonal basis spanning the existing cluster basis and the dominant directions of the fill-in block row, using a truncated SVD of a QR factor; (ii) applies the full orthogonal projection to the admissible, inadmissible, and fill-in parts; and (iii) performs a partial LU elimination on the inadmissible diagonal block, moving the resulting admissible fill-in into F. Multi-level graph coloring partitions clusters into

Load-bearing premise

The entire linear-time argument assumes that the numerical rank of every admissible block and every fill-in block stays below a constant that is independent of the problem size n; if ranks grow with n (for example, with increasing wave number or shrinking correlation length), the O(n) complexity no longer follows and the factorization would require recompression.

What would settle it

Construct a strongly admissible H2 matrix whose off-diagonal blocks have rank that grows with the matrix size—for example, a Helmholtz kernel with wavenumber proportional to the mesh resolution, or a covariance matrix with a short correlation length—factor it at increasing sizes, and check whether the time per unknown and memory per unknown stay flat. If either grows with n, the linear-complexity claim is falsified for that class of problems.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • If the reported scaling holds, direct solves of dense structured systems with one million unknowns are practical on a single many-core CPU node, with memory usage growing only linearly in n.
  • The blackbox nature—only the H2 matrix and right-hand side are needed, without geometric or analytic information—means the solver can be dropped into existing computational workflows for Gaussian processes, integral equations, and kernel methods.
  • The solve phase shares the hierarchical matrix-vector structure, so forward and backward substitutions for multiple right-hand sides inherit the same linear-time per-solve cost.
  • Backward errors stay at the level of the specified truncation thresholds (relative errors in the 1e-6 to 1e-7 range in the reported tests), supporting use as a numerical solver rather than merely a preconditioner.
  • Because all operations are marshaled into batches with preplanned memory allocation, the algorithm is structured for GPU execution; the paper reports a CPU implementation and states that a GPU implementation is in progress.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Inference: The paper's linear-complexity claim rests on an unproven bounded-rank assumption, and its own test problems are described as a 'sweet spot.' For problems with genuinely rank-growing blocks—such as high-frequency oscillatory kernels—the algorithm as presented may need intermediate recompression before it is truly blackbox for all H2 matrices.
  • Inference: The QR-then-SVD basis augmentation avoids the condition-number squaring of Gram-matrix approaches, so the method is structurally well suited to lower-precision execution; the paper discusses lower-precision alternatives but does not test them, making single- or mixed-precision runs a natural next experiment.
  • Inference: The practical constants in the O(Csp^2 k^3 n) estimate are strongly affected by problem dimension and by choices such as leaf size and admissibility parameter η; users may need to tune these per application, especially for 3D problems where observed sparsity constants and ranks are substantially larger.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. The paper presents factorization and solve phases for a strong-admissibility H2 direct solver based on recursive skeletonization, with a focus on batched, fine-grained parallel execution. The algorithmic contributions are a multi-level graph coloring to identify independent skeletonization steps, QR-based basis augmentation to accommodate Schur-complement fill-in, prefix-sum memory management, and a hierarchical forward/backward solve. The complexity analysis in §2.4 claims O(C_sp^2 k^3 n) factorization and O(C_sp k^2 n) solve, linear under a bounded-rank assumption. Experiments on four dense matrix families (2D/3D covariance, 2D Laplace integral equation, 3D Helmholtz integral equation, low-rank update) up to n=2^20 show near-linear time and memory scaling and backward errors near the requested tolerance. A CPU implementation is measured; a GPU implementation is stated as in progress.

Significance. If the linear-complexity claim holds under the stated assumptions, the solver would be a valuable tool for dense and data-sparse systems, particularly because it is blackbox with respect to the origin of the matrix and is designed for batched execution. The paper gives unusually detailed algorithmic steps and includes an experimental backward-error study, and the authors state an intention to release code. However, the central complexity theorem is explicitly conditional on a uniform bound on numerical rank k, including ranks of fill-in bases, and this premise is not proved. The experiments are deliberately in a 'sweet spot' where ranks do not grow substantially. The unqualified 'linear complexity' claim in the title and abstract therefore overreaches the evidence, and additional analysis or careful qualification is needed before the central claim can be accepted.

major comments (4)
  1. [§2.4 and §3.1] The complexity bound is stated in §2.4 as 'if we assume a bound k on the rank.' This is precisely the load-bearing assumption. The manuscript does not prove that the augmented bases or the ranks of fill-in blocks generated during Schur complement updates remain bounded by a constant independent of n. Section 3.1 concedes that the four test problems 'occupy a sweet spot' and that 'in more general cases ... some intermediate recompression may be required.' Since recompression is not part of the presented algorithm, the advertised 'linear complexity direct solver' is conditional rather than demonstrated. The experiments up to n=2^20 cannot distinguish a truly linear algorithm from one with slowly growing rank, e.g., k=O(log n) or O(n^ε), whose complexity is superlinear. The authors should either provide a theorem with precise conditions under which the rank bound holds, or explicitly qualif
  2. [§2.1, step 4] The statement 'By construction, the fill-in blocks are always admissible' is used to justify that fill-in is low-rank, but admissibility is a geometric separation condition, not a rank bound. The augmented basis computed in Algorithm 2 via a truncated SVD of (I - V_i V_i^T) F_{i*} controls the one-step approximation error for a single cluster; it does not control the ranks of blocks generated by later partial LU updates, which can accumulate contributions from multiple clusters. The argument needs an induction establishing a uniform bound on the ranks of all fill-in blocks across all levels. This missing step is load-bearing for the O(n) factorization and solve bounds.
  3. [§3 and Figs. 13, 16] The evidence for linear scaling is visual: O(n) reference lines are overlaid on log-log plots, but no slopes, confidence intervals, or numbers of runs are reported. With the tested range up to n=2^20, the plots cannot rule out log-linear or mildly superlinear behavior. I recommend reporting factorization and solve times in tabular form, fitting slopes with confidence intervals, plotting the maximum rank or rank distribution as a function of n for each family, and comparing against a baseline solver (e.g., a standard H2 or HODLR solver). Also state whether the timings are single runs or averaged, and include error bars if repeats were performed.
  4. [§3.3, Table 3] The thread-scaling results are not uniformly consistent with the abstract's claim of 'parallel scaling up to 16 threads.' For the 2D factorization, the time at 16 threads (7.881 s) is worse than at 8 threads (7.099 s), and the large QR batched operation also degrades between 8 and 16 threads (179.65 ms to 198.18 ms). The text acknowledges 'seemingly poor scaling' but the abstract's wording is stronger than the data. Please either qualify the scaling claim or investigate the source of the degradation (e.g., memory bandwidth, false sharing, OpenMP overhead) and report whether the same behavior would be expected on a GPU.
minor comments (6)
  1. [§1.2] Typo: 'motivated by the needed to reduce rank growth' should be 'motivated by the need to reduce rank growth.'
  2. [§3.1] Minor formatting: 'correlations lengthslset to' should read 'correlation lengths l set to'.
  3. [Algorithm 1] Line 6, 'F=fillIn(A,F,l)', is not defined in the pseudocode or text. Clarify how the fill-in matrix is extracted and how it interacts with levels.
  4. [Algorithm 2] Line 3 uses the notation V_i for the cluster basis and F_{i*} for a block row of the fill-in matrix, but the dimensions are not stated. Add a sentence explaining the exact matrix view used in the SVD, especially since the fill-in blocks may be rectangular.
  5. [Conclusion] The paper says 'we are releasing code for the solver in open-source,' but no repository URL or availability statement is given. Please provide a link or a footnote with the intended release location.
  6. [Figure captions] Figures 13 and 16 should state the number of runs and whether the plotted points are medians, means, or single measurements. Also clarify what the O(n) reference lines mean (e.g., arbitrary constant offset).

Circularity Check

0 steps flagged

No significant circularity: the linear-complexity claim is an explicitly conditional complexity bound plus empirical scaling, and the only self-citation ([7]) is a non-load-bearing construction dependency.

full rationale

The paper's central derivation is an algorithm plus a complexity analysis. The O(C_sp^2 k^3 n) factorization and O(C_sp k^2 n) solve bounds in §2.4 are derived from per-cluster work counts and are explicitly conditional on a bounded numerical rank k and constant sparsity constant C_sp; the text says 'if we assume a bound k on the rank.' These assumptions are stated, not hidden fits, and the experimental sections measure scaling on problems whose ranks the paper itself characterizes as a 'sweet spot' (§3.1), with a concession that general cases may require recompression. This is an honest limitation rather than a circular derivation: the measured linear scaling is not used to define the complexity claim, and no fitted parameter is renamed as a prediction. The only self-citation is [7], used to construct two test matrices and as background; it does not carry the factorization or solve derivation, whose correctness is presented through Algorithms 1-3 and Eq. (2.1). No uniqueness theorem or ansatz is imported from the authors' prior work in a load-bearing way. Therefore no step reduces to its own input by construction.

Axiom & Free-Parameter Ledger

7 free parameters · 5 axioms · 0 invented entities

The central complexity claim is conditional on bounded rank and sparsity, which are standard assumptions for H2 matrices but not guaranteed for arbitrary inputs. The listed experimental parameters are hand chosen to create test problems in the favorable regime. No new physical entities are introduced.

free parameters (7)
  • Leaf size m = 64 or 128
    Chosen per test problem in Table 2; sets the granularity of leaf blocks and affects measured ranks and runtimes.
  • Chebyshev interpolation order p0 = 4 or 8
    Leaf-level polynomial degree used to construct H2 test matrices from kernels (Table 2).
  • Admissibility parameter eta = 0.7 or 0.9
    Strength of the admissibility condition in Eq. (1.1); changes sparsity constant and ranks (Table 2).
  • Diagonal regularization alpha_r = 1e-2 or 1e-5
    Added to the diagonals of test matrices to moderate condition numbers (Section 3).
  • Algebraic compression tolerance epsilon = 1e-7 or 1e-8
    Threshold for constructing and compressing the initial H2 representation (Table 2).
  • LU factorization tolerance epsilon_lu = 1e-6 or 1e-7
    Threshold for truncating fill-in basis vectors during factorization; epsilon_fill = epsilon_lu * ||A|| (Section 2.1).
  • Kernel parameters (correlation length l, wavenumber kappa) = l=0.1 or 0.2, kappa=3
    Kernel parameters for covariance and Helmholtz test matrices; chosen to keep problems in the favorable low-rank regime (Section 3.1).
axioms (5)
  • domain assumption Bounded numerical rank k for all clusters and fill-in blocks throughout factorization
    Section 2.4: 'if we assume a bound k on the rank'; Section 3.1 calls test problems a 'sweet spot'.
  • domain assumption Bounded sparsity constant C_sp independent of n
    Section 2.4: 'the sparsity constant does not grow with problem size'; depends on admissibility and geometry.
  • domain assumption Fill-in blocks produced by partial LU are always admissible
    Section 2.1, step 4: 'By construction, the fill-in blocks are always admissible'; asserted, not proven, and needed to keep the algorithm linear.
  • domain assumption Input A is symmetric and real-valued
    Section 1.1 assumes this; all tests are SPD; nonsymmetric extension is claimed but not demonstrated.
  • domain assumption An H2 representation of A is available
    The solver consumes an H2 matrix; the blackbox claim covers factorization and solve, not construction, which may use geometry or sketching (Section 3.1, [7]).

pith-pipeline@v1.3.0-alltime-deepseek · 14874 in / 14280 out tokens · 147319 ms · 2026-08-04T16:59:52.810869+00:00 · methodology

0 comments
read the original abstract

We present factorization and solution phases for a new linear complexity direct solver designed for concurrent batch operations on fine-grained parallel architectures, for matrices amenable to hierarchical representation. We focus on the strong-admissibility-based $\mathcal{H}^2$ format, where strong recursive skeletonization factorization compresses remote interactions. We build upon previous implementations of $\mathcal{H}^2$ matrix construction for efficient factorization and solution algorithm design, which are illustrated graphically in stepwise detail. The algorithms are ``blackbox'' in the sense that the only inputs are the matrix and right-hand side, without analytical or geometrical information about the origin of the system. We demonstrate linear complexity scaling in both time and memory on four representative families of dense matrices up to one million in size. Parallel scaling up to 16 threads is enabled by a multi-level matrix graph coloring and avoidance of dynamic memory allocations thanks to prefix-sum memory management. An experimental backward error analysis is included. We break down the timings of different phases, identify phases that are memory-bandwidth limited, and discuss alternatives for phases that may be sensitive to the trend to employ lower precisions for performance.

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. Parallel Sparse and Data-Sparse Factorization-based Linear Solvers

    cs.MS 2026-02 unverdicted novelty 1.0

    Review chapter summarizing advances in parallel sparse direct solvers along communication reduction and data-sparse compression axes.

Reference graph

Works this paper leans on

27 extracted references · cited by 1 Pith paper

  1. [1]

    Sivaram Ambikasaran and Eric Darve. AnO(NlogN)fast direct solver for partial hierarchically semi- separable matrices: with application to radial basis function interpolation.Journal of Scientific Computing, 57:477–501, 2013

    2013

  2. [2]

    Fast direct methods for Gaussian processes.IEEE Transactions on Pattern Analysis and Machine Intelligence, 38(2):252–265, 2015

    Sivaram Ambikasaran, Daniel Foreman-Mackey, Leslie Greengard, David W Hogg, and Michael O’Neil. Fast direct methods for Gaussian processes.IEEE Transactions on Pattern Analysis and Machine Intelligence, 38(2):252–265, 2015

    2015

  3. [3]

    Existence ofH-matrix approximants to the inverse FE-matrix of elliptic operators withL ∞-coefficients.Numerische Mathematik, 95:1–28, 2003

    Mario Bebendorf and Wolfgang Hackbusch. Existence ofH-matrix approximants to the inverse FE-matrix of elliptic operators withL ∞-coefficients.Numerische Mathematik, 95:1–28, 2003

    2003

  4. [4]

    Approximating Gaussian processes withH 2-matrices

    Steffen B ¨orm and Jochen Garcke. Approximating Gaussian processes withH 2-matrices. InEuropean Conference on Machine Learning, pages 42–53. Springer, 2007

    2007

  5. [5]

    Introduction to hierarchical matrices with applications.Engineering analysis with boundary elements, 27(5):405–422, 2003

    Steffen B ¨orm, Lars Grasedyck, and Wolfgang Hackbusch. Introduction to hierarchical matrices with applications.Engineering analysis with boundary elements, 27(5):405–422, 2003

    2003

  6. [6]

    Efficient arithmetic operations for rank-structured matrices based on hierarchical low-rank updates.Computing and Visualization in Science, 16:247–258, 2013

    Steffen B ¨orm and Kerstin Reimer. Efficient arithmetic operations for rank-structured matrices based on hierarchical low-rank updates.Computing and Visualization in Science, 16:247–258, 2013

    2013

  7. [7]

    Adaptive Sketching Based Construction of H2 Matrices on GPUs

    Wajih Boukaram, Yang Liu, Pieter Ghysels, and Xiaoye Sherry Li. Adaptive Sketching Based Construction of H2 Matrices on GPUs. InThe 26th IEEE International Workshop on Parallel and Distributed Scientific and Engineering Computing (PDSEC 2025). IEEE, 06 2025. Best Paper Award

    2025

  8. [8]

    Hierarchical matrix operations on GPUs: Matrix-vector multiplication and compression.ACM Transactions on Mathematical Software, 45(1):1–28, February 2019

    Wajih Halim Boukaram, George Turkiyyah, and David Keyes. Hierarchical matrix operations on GPUs: Matrix-vector multiplication and compression.ACM Transactions on Mathematical Software, 45(1):1–28, February 2019. LINEAR COMPLEXITYH 2 SOLVER21

    2019

  9. [9]

    A fast solver for HSS representations via sparse matrices.SIAM Journal on Matrix Analysis and Applications, 29(1):67–81, 2007

    Shiv Chandrasekaran, Patrick Dewilde, Ming Gu, William Lyons, and Timothy Pals. A fast solver for HSS representations via sparse matrices.SIAM Journal on Matrix Analysis and Applications, 29(1):67–81, 2007

    2007

  10. [10]

    A superfast algorithm for Toeplitz systems of linear equations.SIAM Journal on Matrix Analysis and Applications, 29(4):1247–1266, 2008

    Shiv Chandrasekaran, Ming Gu, Xiaotian Sun, Jianlin Xia, and Jiang Zhu. A superfast algorithm for Toeplitz systems of linear equations.SIAM Journal on Matrix Analysis and Applications, 29(4):1247–1266, 2008

    2008

  11. [11]

    Scalable and memory- efficient kernel ridge regression

    Gustavo Ch ´avez, Yang Liu, Pieter Ghysels, Xiaoye Sherry Li, and Elizaveta Rebrova. Scalable and memory- efficient kernel ridge regression. In2020 IEEE International Parallel and Distributed Processing Symposium (IPDPS), pages 956–965. IEEE, 2020

    2020

  12. [12]

    The inverse fast multipole method: using a fast approximate direct solver as a preconditioner for dense linear systems.SIAM Journal on Scientific Computing, 39(3):A761– A796, 2017

    Pieter Coulier, Hadi Pouransari, and Eric Darve. The inverse fast multipole method: using a fast approximate direct solver as a preconditioner for dense linear systems.SIAM Journal on Scientific Computing, 39(3):A761– A796, 2017

    2017

  13. [13]

    A robust parallel preconditioner for indefinite systems using hierarchical matrices and randomized sampling

    Pieter Ghysels, Sherry Li Xiaoye, Christopher Gorman, and Franc ¸ois-Henry Rouet. A robust parallel preconditioner for indefinite systems using hierarchical matrices and randomized sampling. In2017 IEEE International Parallel and Distributed Processing Symposium (IPDPS), pages 897–906. IEEE, 2017

    2017

  14. [14]

    A direct solver withO(N)complexity for integral equations on one-dimensional domains.Frontiers of Mathematics in China, 7:217–247, 2012

    Adrianna Gillman, Patrick M Young, and Per-Gunnar Martinsson. A direct solver withO(N)complexity for integral equations on one-dimensional domains.Frontiers of Mathematics in China, 7:217–247, 2012

    2012

  15. [15]

    A sparse matrix arithmetic based onH-matrices

    Wolfgang Hackbusch. A sparse matrix arithmetic based onH-matrices. Part I: Introduction to-matrices. Computing, 62(2):89–108, 1999

    1999

  16. [16]

    Hierarchical algorithms on hierarchical architectures

    David Keyes, Hatem Ltaief, and George Turkiyyah. Hierarchical algorithms on hierarchical architectures. Philosophical Transactions of the Royal Society A: Mathematical, Physical and Engineering Sciences, 378(2166):20190055, January 2020

    2020

  17. [17]

    Ho and Lexing Ying

    Kenneth L. Ho and Lexing Ying. Hierarchical interpolative factorization for elliptic operators: integral equations.Communications on Pure and Applied Mathematics, 69(7):1314–1353, 2016

    2016

  18. [18]

    AnO(N)distributed-memory parallel direct solver for planar integral equations

    Tianyu Liang, Chao Chen, Per-Gunnar Martinsson, and George Biros. AnO(N)distributed-memory parallel direct solver for planar integral equations. In2024 IEEE International Parallel and Distributed Processing Symposium (IPDPS), pages 440–452. IEEE, 2024

    2024

  19. [19]

    Miaomiao Ma and Dan Jiao. Direct solution of generalH 2 -matrices with controlled accuracy and concurrent change of cluster bases for electromagnetic analysis.IEEE Transactions on Microwave Theory and Techniques, 67(6):2114–2127, 2019

    2019

  20. [20]

    Scalable linear time dense direct solver for 3-d problems without trailing sub-matrix dependencies

    Qianxiang Ma, Sameer Deshmukh, and Rio Yokota. Scalable linear time dense direct solver for 3-d problems without trailing sub-matrix dependencies. InSC22: International Conference for High Performance Computing, Networking, Storage and Analysis, pages 1–12. IEEE, 2022

    2022

  21. [21]

    Qianxiang Ma and Rio Yokota. An inherently parallelH 2 -ULV factorization for solving dense linear systems on GPUs.The International Journal of High Performance Computing Applications, 38(4):314–336, April 2024

    2024

  22. [22]

    A fast direct solver for boundary integral equations in two dimensions.Journal of Computational Physics, 205(1):1–23, 2005

    Per-Gunnar Martinsson and Vladimir Rokhlin. A fast direct solver for boundary integral equations in two dimensions.Journal of Computational Physics, 205(1):1–23, 2005

    2005

  23. [23]

    A recursive skeletonization factorization based on strong admissibility.Multiscale Modeling & Simulation, 15(2):768–796, 2017

    Victor Minden, Kenneth L Ho, Anil Damle, and Lexing Ying. A recursive skeletonization factorization based on strong admissibility.Multiscale Modeling & Simulation, 15(2):768–796, 2017

    2017

  24. [24]

    FMM-LU: A Fast Direct Solver for Multiscale Boundary Integral Equations in Three Dimensions.Multiscale Modeling & Simulation, 21(4):1570–1601, 2023

    Daria Sushnikova, Leslie Greengard, Michael O’Neil, and Manas Rachh. FMM-LU: A Fast Direct Solver for Multiscale Boundary Integral Equations in Three Dimensions.Multiscale Modeling & Simulation, 21(4):1570–1601, 2023

    2023

  25. [25]

    Randomized sparse direct solvers.SIAM Journal on Matrix Analysis and Applications, 34(1):197– 227, 2013

    Jianlin Xia. Randomized sparse direct solvers.SIAM Journal on Matrix Analysis and Applications, 34(1):197– 227, 2013

    2013

  26. [26]

    Randomized Strong Recursive Skeletonization: Simultaneous Compression and LU Factorization of Hierarchical Matrices using Matrix-Vector Products, 2025

    Anna Yesypenko and Per-Gunnar Martinsson. Randomized Strong Recursive Skeletonization: Simultaneous Compression and LU Factorization of Hierarchical Matrices using Matrix-Vector Products, 2025

    2025

  27. [27]

    H2Opus: a distributed- memory multi-GPU software package for non-local operators.Advances in Computational Mathematics, 48(3), May 2022

    Stefano Zampini, Wajih Boukaram, George Turkiyyah, Omar Knio, and David Keyes. H2Opus: a distributed- memory multi-GPU software package for non-local operators.Advances in Computational Mathematics, 48(3), May 2022

    2022