IterativeCUR: CUR-Based Iterative Matrix Methods

• IterativeCUR is a family of methods that iteratively update low-rank matrix approximations using selected rows and columns instead of full SVDs.
• It is applied across domains such as implicit time integration, rank-adaptive approximations, robust PCA, and DEIM-based refinements, each with tailored update strategies.
• The approach reduces computational cost by leveraging sampled substructures and adaptive residual corrections to efficiently maintain accurate CUR decompositions.

IterativeCUR denotes a family of iterative methods built around CUR-style low-rank approximation, in which a matrix is represented or updated from selected columns and rows rather than from repeated full SVDs or full residual evaluations. The name is not standardized across the literature: it has been used for an implicit Newton-collocated time integrator for stiff matrix differential equations arising from random PDEs, a rank-adaptive CUR decomposition driven by a recycled residual sketch, iterative DEIM-CUR subselection strategies, and CUR-accelerated solvers for robust PCA (Naderi et al., 2024, Pritchard et al., 26 Sep 2025, Gidisu et al., 2023, Cai et al., 2020). The common motif is the use of actual sampled matrix substructures to control cost while retaining low-rank structure.

1. Terminological scope

The literature uses the name in several distinct but related senses.

Usage	Defining iteration	Representative paper
Implicit time integration of random PDEs	Newton iterations inside implicit multistep or DIRK schemes, with CUR updates from selected rows and columns	(Naderi et al., 2024)
Rank-adaptive matrix approximation	Residual-sketch downdating with repeated blockwise row and column selection	(Pritchard et al., 26 Sep 2025)
Robust PCA	Alternating hard thresholding and CUR low-rank updates on sampled submatrices	(Cai et al., 2020)
Deterministic DEIM-CUR refinement	Multi-round residual deflation with iterative SVD-based reselection	(Gidisu et al., 2023)

A direct consequence is that algorithmic details attached to the term are domain dependent. In some papers IterativeCUR is a matrix approximation routine; in others it is embedded inside an implicit integrator or a nonconvex alternating method. This suggests that the term should be read as a methodological label for iterative CUR-based computation rather than as the name of a single canonical algorithm.

2. Shared CUR structure and iterative design

At the algebraic level, the common template is the CUR approximation

$A \approx C U R,$

where $C = A(:,J)$ contains selected columns, $R = A(I,:)$ contains selected rows, and the core is often taken in cross form as

$U = A(I,J)^\dagger.$

Interpolatory variants write

$CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$

These formulas appear in several versions of IterativeCUR, although the selection rules and update mechanisms differ across applications (Pritchard et al., 26 Sep 2025, Naderi et al., 2024).

Several papers emphasize why this representation is attractive. Because CUR uses direct matrix subsets, it can preserve native matrix structures such as sparsity or non-negativity and can facilitate interpretation more naturally than SVD-based factors. In addition, the sampled rows and columns are often much cheaper to update than the full matrix, which makes CUR well suited to residual-driven or time-stepping procedures (Pritchard et al., 26 Sep 2025, Voronin et al., 2014).

The “iterative” aspect enters in multiple ways. In stiff time integration it refers to Newton iterations within each implicit step. In adaptive matrix approximation it refers to repeated residual-sketch downdating and blockwise pivoting. In robust PCA it appears as alternating sparse and low-rank updates. In DEIM-CUR refinement it means residual deflation followed by reselection of informative indices. Across these variants, the residual or correction is the main object being updated rather than the entire matrix itself.

3. Implicit Newton–CUR time integration on low-rank manifolds

In the random-PDE setting, IterativeCUR refers to an implicit, Newton-based CUR time-integration procedure for low-rank matrix differential equations produced by discretizing

$\frac{\partial v}{\partial t}=f(v;x,t,\xi),$

into

$$\frac{dV}{dt}=\mathcal F(V), \qquad V(t)\in\mathbb R^{n\times s}.$$

Rows correspond to spatial degrees of freedom and columns to parameter or sampling realizations. The paper targets stiff, nonlinear, and very large matrix differential equations, especially those arising from diffusion, reaction, or second-order spatial operators, and therefore focuses on implicit multistep schemes AM2 and BDF2–BDF4 together with DIRK2–DIRK4 (Naderi et al., 2024).

The low-rank state is written as

$\hat V(t)=U(t)\Sigma(t)Y(t)^\top,$

with orthonormal spatial and parametric bases. The paper’s central shift is from tangent-space projection alone to a residual-collocation view. For implicit Euler,

$R(V^k)=V^k - V^{k-1}-\Delta t\,\mathcal F(V^k),$

and the method enforces the implicit equations only at selected rows and columns. Selected columns $V^k(:,s)$ are solved implicitly using deterministic solvers, independently for each selected sample. For the row update, the Newton correction is approximated in a low-rank basis,

$C = A(:,J)$0

and collocation at DEIM-selected rows gives

$C = A(:,J)$1

or, with oversampling,

$C = A(:,J)$2

DEIM or QDEIM chooses the sampled columns and rows adaptively in time, and GappyPOD+E is used for oversampling and conditioning (Naderi et al., 2024).

The method is explicitly rank-adaptive. Its error proxy is

$C = A(:,J)$3

with the rule to increase rank when $C = A(:,J)$4 and decrease rank when $C = A(:,J)$5. In the stiff linear advection-diffusion test, explicit RK was limited to around $C = A(:,J)$6, while the implicit method used $C = A(:,J)$7 as large as $C = A(:,J)$8. For stochastic Burgers’ equation with $C = A(:,J)$9, AM2 cost per iteration was reported as 12.2 s for the FOM, 0.6 s for TDB-CUR with $R = A(I,:)$0, and 1.2 s for TDB-CUR with $R = A(I,:)$1. The same study reports close tracking of leading singular values, high-order convergence for DIRK4 and BDF4, and relative error below $R = A(I,:)$2 on a stochastic 2D Gray-Scott problem (Naderi et al., 2024).

4. Robust PCA: IRCUR and its Riemannian extension

In robust PCA, IterativeCUR appears as Iterated Robust CUR, or IRCUR, for matrices satisfying

$R = A(I,:)$3

where $R = A(I,:)$4 is low-rank and $R = A(I,:)$5 is sparse. The nonconvex target is

$R = A(I,:)$6

IRCUR alternates two phases. Phase I updates the sparse term by hard thresholding only the sampled rows and columns needed for the subsequent CUR step. Phase II updates the low-rank term from three small submatrices,

$R = A(I,:)$7

followed by

$R = A(I,:)$8

The full matrix $R = A(I,:)$9 is not formed in practice; only the CUR factors are maintained. The stopping criterion likewise uses sampled submatrices only. Under the paper’s accounting, the usual per-iteration cost of about $U = A(I,J)^\dagger.$0 is reduced to $U = A(I,J)^\dagger.$1 (Cai et al., 2020).

Two sampling variants are distinguished. IRCUR-F keeps the sampled row and column sets fixed, which minimizes data access and is slightly more efficient in runtime. IRCUR-R resamples, uses more redundant data, and is intended to be more robust when initial samples are unlucky. On video background subtraction, reported runtimes were 2.03 s and 2.16 s for IRCUR-F and IRCUR-R on shoppingmall, versus 23.04 s for AccAltProj and 93.18 s for GD; on restaurant the corresponding numbers were 0.82 s, 0.88 s, 15.96 s, and 58.37 s (Cai et al., 2020).

A later robust-PCA development, RieCUR, preserves IRCUR’s CUR sampling and low-memory structure but inserts a tangent-space projection,

$U = A(I,J)^\dagger.$2

before CUR reconstruction. The low-rank iterate becomes

$U = A(I,J)^\dagger.$3

but now $U = A(I,J)^\dagger.$4 are extracted from $U = A(I,J)^\dagger.$5 rather than directly from $U = A(I,J)^\dagger.$6. The stated effect is improved robustness to outliers relative to IRCUR at the same asymptotic complexity $U = A(I,J)^\dagger.$7, though the paper does not provide a full convergence theorem for RieCUR (Hamm et al., 2022).

5. Rank-adaptive CUR via a recycled residual sketch

A different usage of IterativeCUR is the rank-adaptive CUR decomposition algorithm based on a single recycled sketch of the residual. For $U = A(I,J)^\dagger.$8, the approximation takes the cross form

$U = A(I,J)^\dagger.$9

Rather than asking for a target rank, the method takes a tolerance $CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$0 and increases the rank in blocks of size $CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$1 until the sketched residual is sufficiently small (Pritchard et al., 26 Sep 2025).

The algorithm starts from a Gaussian sketching matrix

$CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$2

and maintains the column residual sketch

$CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$3

Columns are chosen from the current sketch, typically by LUPP or QRCP; rows are then selected from the row residual associated with the newly chosen columns; the core is updated as $CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$4; and the sketch is downdated rather than recomputed. The stopping quantity is

$CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$5

with termination when $CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$6. The paper also gives a risk-aware threshold adjustment using a probabilistic bound for Gaussian sketching (Pritchard et al., 26 Sep 2025).

A central design point is the use of one sketch throughout. Repeated multiplication by the full matrix would be too expensive, so the residual sketch is successively downdated by subtracting the sketched contribution of the new CUR factors. Because the method uses the cross approximation $CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$7, row and column choices are selected dependently rather than independently. The stated dense-matrix complexity is

$CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$8

and reported experiments show up to $CUR(V) = V(:,s)\,V(p,s)^{-1}\,V(p,:).$9 speed-up over state-of-the-art pivoting-on-sketch approaches with no loss of accuracy, and up to $\frac{\partial v}{\partial t}=f(v;x,t,\xi),$0 speed-up over rank-adaptive randomized SVD approaches (Pritchard et al., 26 Sep 2025).

6. Iterative subselection, DEIM-CUR, and iterative SVDs

Another line of work uses IterativeCUR to mean iterative subselection in DEIM-CUR factorization. Standard one-round CUR computes a singular-vector basis once, selects all $\frac{\partial v}{\partial t}=f(v;x,t,\xi),$1 rows and columns in a single pass, and forms $\frac{\partial v}{\partial t}=f(v;x,t,\xi),$2. The iterative variant instead selects indices in several rounds, removes the part of the matrix already explained, recomputes singular information on the residual, and applies DEIM again. The guiding sequence is to build a partial CUR approximation, form a residual, compute singular vectors of that residual, choose new indices, and repeat until the target rank is reached (Gidisu et al., 2023).

Two residual definitions are emphasized. One-sided strategies use

$\frac{\partial v}{\partial t}=f(v;x,t,\xi),$3

or its row analogue. The more CUR-faithful strategy uses the two-sided residual

$\frac{\partial v}{\partial t}=f(v;x,t,\xi),$4

The paper develops fixed-round and singular-value-decay-driven selection rules, including DADP-CUR, which zeroes out previously used singular-vector entries to avoid reselection. For large matrices, full SVD recomputation is replaced by an iterative SVD based on Krylov–Schur and Lanczos bidiagonalization, and the residual matrix need not be formed explicitly (Gidisu et al., 2023).

The reported experiments compare iterative subselection against DEIM, QDEIM, MaxVol, and randomized baselines on synthetic sparse data and on Reuters-21578, TechTC, g7jac100, and invextr1-new. The main reported outcome is that the proposed iterative subselection methods outperform standard one-round methods in relative approximation error. On Reuters, the large-scale iterative-SVD version achieves essentially the same approximation error as the full-SVD version while reducing runtime from thousands of seconds to tens of seconds. The TechTC case is also used to illustrate interpretability, with selected terms such as “evansville,” “florida,” “miami,” and “indiana” (Gidisu et al., 2023).

7. Lineage, extensions, and interpretive cautions

A useful antecedent is the QR/ID-based CUR construction in which a rank-$\frac{\partial v}{\partial t}=f(v;x,t,\xi),$5 column-pivoted QR is converted into a one-sided interpolative decomposition, then into a two-sided interpolative decomposition, and finally into a CUR factorization with

$\frac{\partial v}{\partial t}=f(v;x,t,\xi),$6

That framework shows how CUR can be assembled from modified truncated pivoted QR, with randomized Gaussian sketches, SRFTs, and power iterations used for acceleration. It is not itself an IterativeCUR method, but it provides a practical skeletonization pipeline from which later residual-driven and adaptive variants depart (Voronin et al., 2014).

Subsequent extensions broaden the same idea to other operator settings. A CUR Krylov solver for large-scale linear matrix equations uses DEIM-selected rows and columns, removes the dependence between selected and unselected entries through CUR interpolation formulas, solves the resulting reduced row and column equations by matrix-form GMRES, and incorporates rank adaptivity. The paper reports inner fixed-point iterations typically converging in about 5–15 iterations and discusses generalized Sylvester, generalized Lyapunov, and non-Sylvester equations with Hadamard terms (Akbari et al., 18 Nov 2025).

At the same time, the name should not be extended indiscriminately. ALFS formulates joint active learning and feature selection through the CUR-inspired reconstruction objective

$\frac{\partial v}{\partial t}=f(v;x,t,\xi),$7

and solves it by ADMM, but the actual sample and feature selection is one-shot rather than progressive (Li et al., 2015). RPIA is explicitly described as not being CUR decomposition; it is a randomized block-coordinate version of PIA/LSPIA for B-spline fitting, connected to CUR only at a conceptual level through local randomized updates and avoidance of full system formation (Wu et al., 2022). This suggests that IterativeCUR is best understood as a context-sensitive label for iterative computation with CUR-style sampling, rather than a single universally agreed algorithmic object.