NA-Hutch++: Non-Adaptive Trace Estimator

Updated 5 July 2026

NA-Hutch++ is a non-adaptive stochastic trace estimator that splits a fixed query budget between low-rank approximation and Hutchinson residual correction.
It leverages a pre-determined, one-shot sketching approach to reduce variance and improve parallelism in matrix trace estimation.
The method is effective in streaming and low-memory settings but relies on sufficient low-rank structure for optimal performance.

Non-Adaptive Hutch++ (NA-Hutch++) is a non-adaptive Hutch++-style stochastic trace estimator for matrices accessed through matrix-vector products. Its defining idea is to split a fixed query budget between a randomized low-rank approximation and a Hutchinson estimator applied only to the residual, with all queries chosen in advance rather than sequentially. In the randomized numerical linear algebra literature, it is the non-adaptive analogue of Hutch++, while in streaming and application-specific settings it also serves as a one-shot sketching primitive, a single-pass trace estimator, and, in one recent PDE data-reduction application, an online a posteriori estimator of Frobenius reconstruction error rather than a direct low-rank constructor (Meyer et al., 2020, Jiang et al., 2021, Li et al., 2024).

1. Origins, naming, and conceptual position

The modern lineage begins with Hutchinson’s estimator, which approximates $\operatorname{tr}(A)$ from quadratic forms $g_i^\top A g_i$ and, for positive semidefinite (PSD) matrices, requires $O(\log(1/\delta)/\epsilon^2)$ matrix-vector queries for a $(1\pm\epsilon)$ approximation with failure probability $\delta$ . Hutch++ introduced a variance-reduction principle: first capture the dominant eigenspace of $A$ , then run Hutchinson only on the residual, reducing the $\epsilon$ -dependence from $O(1/\epsilon^2)$ to $O(1/\epsilon)$ at constant success probability (Meyer et al., 2020).

A terminological complication is that the literature does not use a single label consistently. The 2020 Hutch++ paper explicitly introduces a non-adaptive variant under the name NA-Hutch, not “NA-Hutch++” (Meyer et al., 2020). Subsequent literature, however, uses NA-Hutch++ for the non-adaptive Hutch++ family and for the single-pass variant; one paper states explicitly that “The Single Pass Hutch++ mentioned above is called NA-Hutch++ (non-adaptive variant of Hutch++) in \cite{hpp}” (Persson et al., 2021). Another paper frames its contribution as an “improved analysis of the non-adaptive trace estimation algorithm NA-Hutch++” (Jiang et al., 2021). In practice, therefore, “NA-Hutch++” denotes the non-adaptive Hutch++ architecture rather than a universally fixed notation.

The conceptual distinction from adaptive Hutch++ is query adaptivity. Adaptive Hutch++ first forms a sketch such as $AS$ , computes a basis from the observed sketch, and then issues further matrix-vector products depending on that basis. NA-Hutch++ instead fixes all probe directions in advance. This makes non-adaptive methods exactly sketching algorithms: they are mergeable, highly parallelizable, suitable for low-memory streaming, and useful in distributed settings with low communication (Jiang et al., 2021).

Paper	Role in the development of NA-Hutch++	Key point
(Meyer et al., 2020)	Introduces the non-adaptive variant as “NA-Hutch”	PSD guarantee with $g_i^\top A g_i$ 0 queries
(Jiang et al., 2021)	Improves high-probability analysis of NA-Hutch++	$g_i^\top A g_i$ 1 queries
(Persson et al., 2021)	Clarifies naming around single-pass Hutch++	Explicitly links single-pass Hutch++ to NA-Hutch++
(Li et al., 2024)	Adapts NA-Hutch++ to streaming PDE data reduction	Single-pass online a posteriori error estimation

2. Canonical estimator structure

NA-Hutch++ is built around a “low-rank plus residual” decomposition. For a PSD matrix $g_i^\top A g_i$ 2 and total budget $g_i^\top A g_i$ 3, choose constants $g_i^\top A g_i$ 4 with $g_i^\top A g_i$ 5 and $g_i^\top A g_i$ 6. Draw three independent Gaussian matrices

$g_i^\top A g_i$ 7

compute

$g_i^\top A g_i$ 8

and return

$g_i^\top A g_i$ 9

All matrix-vector products $O(\log(1/\delta)/\epsilon^2)$ 0, $O(\log(1/\delta)/\epsilon^2)$ 1, and $O(\log(1/\delta)/\epsilon^2)$ 2 can be requested in one shot, hence fully in parallel (Jiang et al., 2021).

This estimator has two components. The low-rank captured part is

$O(\log(1/\delta)/\epsilon^2)$ 3

and its trace is represented by the first term. The residual

$O(\log(1/\delta)/\epsilon^2)$ 4

is handled by a Hutchinson correction using the independent sketch $O(\log(1/\delta)/\epsilon^2)$ 5. In this sense, NA-Hutch++ retains the central Hutch++ mechanism—variance reduction by deflation—while removing query adaptivity (Jiang et al., 2021).

The original 2020 presentation gives the same architecture in slightly different notation and emphasizes that NA-Hutch requires exactly $O(\log(1/\delta)/\epsilon^2)$ 6 matrix-vector multiplications with $O(\log(1/\delta)/\epsilon^2)$ 7, partitioned into $O(\log(1/\delta)/\epsilon^2)$ 8 queries for $O(\log(1/\delta)/\epsilon^2)$ 9, $(1\pm\epsilon)$ 0 queries for $(1\pm\epsilon)$ 1, and $(1\pm\epsilon)$ 2 queries for $(1\pm\epsilon)$ 3. It also records postprocessing costs of $(1\pm\epsilon)$ 4 for matrix multiplications and $(1\pm\epsilon)$ 5 including the pseudoinverse computation, assuming $(1\pm\epsilon)$ 6 (Meyer et al., 2020).

A recurring practical choice is

$(1\pm\epsilon)$ 7

which is the split used in experiments following prior recommendations (Jiang et al., 2021).

3. Guarantees, complexity, and optimality

The first high-probability guarantee for the non-adaptive variant appears in the 2020 Hutch++ paper. For PSD $(1\pm\epsilon)$ 8, if NA-Hutch is implemented with

$(1\pm\epsilon)$ 9

matrix-vector multiplication queries and $\delta$ 0 is a sufficiently large constant, then with probability at least $\delta$ 1 the estimate satisfies

$\delta$ 2

The same paper also proves a non-adaptive lower bound

$\delta$ 3

showing that the $\delta$ 4-dependence is essentially optimal for non-adaptive trace estimation (Meyer et al., 2020).

The 2021 analysis sharpens the high-probability dependence on $\delta$ 5. It shows that NA-Hutch++ can achieve

$\delta$ 6

matrix-vector products while retaining non-adaptivity, matching adaptive Hutch++ up to constants in the upper bound. The same paper proves a matching lower bound

$\delta$ 7

so the upper bound is tight up to a $\delta$ 8 factor in the additive term (Jiang et al., 2021).

The technical reason the improved bound is possible is that the cost of non-adaptive low-rank approximation can be reduced from the previously used

$\delta$ 9

queries to

$A$ 0

Specifically, for PSD $A$ 1, if $A$ 2 and $A$ 3 have i.i.d. $A$ 4 entries, then with

$A$ 5

the approximation

$A$ 6

satisfies

$A$ 7

with probability $A$ 8 (Jiang et al., 2021).

This interacts with the standard Hutch++ residual tradeoff. If

$A$ 9

and $\epsilon$ 0 is Hutchinson’s estimator with $\epsilon$ 1 residual queries, then with high probability

$\epsilon$ 2

obeys an error bound proportional to

$\epsilon$ 3

Balancing $\epsilon$ 4 and $\epsilon$ 5 at

$\epsilon$ 6

produces the improved non-adaptive complexity (Jiang et al., 2021).

4. Single-pass and streaming formulations

NA-Hutch++ acquires a distinct role in the online interpolative decomposition framework for temporal PDE data reduction. There the data matrix is

$\epsilon$ 7

with each column $\epsilon$ 8 a PDE snapshot at time $\epsilon$ 9, and the target approximation is a column interpolative decomposition

$O(1/\epsilon^2)$ 0

The exact best coefficient matrix would be

$O(1/\epsilon^2)$ 1

but that requires access to the full matrix. The online algorithm therefore forms four candidate coefficient matrices $O(1/\epsilon^2)$ 2, $O(1/\epsilon^2)$ 3, and uses NA-Hutch++ to estimate which one yields the smallest reconstruction error in real time (Li et al., 2024).

The residual matrix is

$O(1/\epsilon^2)$ 4

and the quantity of interest is

$O(1/\epsilon^2)$ 5

Thus the matrix whose trace is estimated is

$O(1/\epsilon^2)$ 6

The online decision rule is

$O(1/\epsilon^2)$ 7

where $O(1/\epsilon^2)$ 8 is the NA-Hutch++ estimate of the reconstruction error for candidate $O(1/\epsilon^2)$ 9, and the selected coefficient matrix is

$O(1/\epsilon)$ 0

In this setting, NA-Hutch++ is not used to construct the low-rank approximation itself; it is an a posteriori estimator of reconstruction quality and a decision mechanism for coefficient selection (Li et al., 2024).

The formulation specialized to $O(1/\epsilon)$ 1 uses three sub-Gaussian random matrices

$O(1/\epsilon)$ 2

with $O(1/\epsilon)$ 3 and $O(1/\epsilon)$ 4. With

$O(1/\epsilon)$ 5

the paper writes the NA-Hutch++ trace estimator as

$O(1/\epsilon)$ 6

A crucial adaptation is that the algorithm does not run NA-Hutch++ as a separate standalone routine. Instead it reuses the Gaussian random projection matrix

$O(1/\epsilon)$ 7

already formed for sketching the streaming data, samples rows of $O(1/\epsilon)$ 8 without duplicated rows to obtain $O(1/\epsilon)$ 9, $AS$ 0, and $AS$ 1, and reuses the corresponding rows of the sketched residual data (Li et al., 2024).

The streaming implementation rests on the additive identity

$AS$ 2

Hence the trace can be accumulated column by column as each snapshot arrives. For a new column $AS$ 3, the algorithm computes $AS$ 4, forms the rank-1 query matrix $AS$ 5, samples row index sets $AS$ 6, defines

$AS$ 7

and updates the running estimate of $AS$ 8. The resulting error estimator is single-pass, sketch-reusing, and integrated directly into the online randomized ID workflow (Li et al., 2024).

5. Empirical performance and failure modes

In the trace-estimation literature proper, NA-Hutch++ is empirically reported to have far fewer failures than Hutchinson on PSD problems for the same number of queries. In sequential execution its running time is similar to adaptive Hutch++, but in parallel execution it is much faster because all queries can be issued simultaneously. The reported practical conclusion is that NA-Hutch++ offers the best tradeoff between accuracy and parallel speed among the compared methods, while plain Hutchinson remains simpler but typically worse in query complexity and accuracy when the spectrum has nontrivial decay (Jiang et al., 2021).

The online PDE-data-reduction study reports that the single-pass Hutch++ method accurately estimates the relative Frobenius error and determines the coefficient matrix with the least reconstruction error on turbulent channel flow, ignition simulations, and the NSTX Gas Puff Image dataset. The experimental tables include both the true relative Frobenius error and the estimated error from single-pass Hutch++/NA-Hutch++, and the estimator is reported to guide adaptive coefficient-update selection effectively across all three datasets (Li et al., 2024).

A contrasting empirical picture appears in lattice QCD. There, a Hutch++-type non-adaptive inexact-deflation estimator for $AS$ 9 shows no noise reduction with a moderate number of sources/inversions and fails to outperform Girard-Hutchinson up to roughly $g_i^\top A g_i$ 00 inversions. The paper attributes this to the weakness of the captured low-rank component: for the light quark, the deflation space becomes relevant only after roughly $g_i^\top A g_i$ 01 inversions; for the charm quark, only after more than $g_i^\top A g_i$ 02 inversions; and even then the relative contribution of the deflation space remains of order $g_i^\top A g_i$ 03 for very high cost. The same study therefore treats effective low-rank structure as the decisive regime condition for success (Cotellucci et al., 2023).

This regime dependence also appears in a Hutch++-inspired stochastic resolution-of-identity method for second-order Green’s function calculations. There, Hutch++-like low-rank-plus-residual approximations are computationally more efficient than deterministic and purely stochastic approaches for low error thresholds and intermediate system sizes, but for arbitrarily large systems the Hutchinson-like approximation outperforms both deterministic and Hutch++-like methods. A plausible implication is that NA-Hutch++-style variance reduction is strongest when the target operator has enough trace-relevant low-rank structure that the residual becomes genuinely easier than the original problem (Mejía et al., 2024).

NA-Hutch++ sits inside a larger family of sketch-and-correct estimators. One line of work argues that fixed sample splitting wastes information and replaces it with exchangeable leave-one-out symmetrization. XTrace and XNysTrace use all test vectors for low-rank approximation and all test vectors for residual trace estimation, remain unbiased, and achieve $g_i^\top A g_i$ 04 variance like Hutch++, while often outperforming Hutch++ by orders of magnitude on rapidly decaying spectra under equal matvec budgets. This places non-adaptivity only on one axis of design; exchangeability and sample reuse form another (Epperly et al., 2023).

Another line concerns one-pass PSD variants. An improved-variants paper develops Nyström++, which replaces the randomized-SVD approximation by the Nyström approximation

$g_i^\top A g_i$ 05

and proves a Hutch++-type relative-error guarantee for SPSD matrices using

$g_i^\top A g_i$ 06

matrix-vector products. The same paper reports that “Single Pass Hutch++ is the weakest alternative” among the tested one-pass methods, whereas Hutch++ and Nyström++ are often similar and Nyström++ can sometimes outperform Hutch++ (Persson et al., 2021).

Application papers also show that the label “Hutch++” is often used for structurally non-adaptive implementations without explicit attention to naming. A matrix-free NTK paper draws random sketch and probe matrices upfront, forms

$g_i^\top A g_i$ 07

and estimates the residual trace with independent projected probes, which matches the usual non-adaptive Hutch++ pattern even though the paper discusses only “Hutch++” (Hazelden, 13 Nov 2025). A recent matrix-free norm-estimation paper develops TwINEst++, a diagonal-estimation analogue that approximates

$g_i^\top A g_i$ 08

again using a low-rank sketch plus a Hutchinson residual correction with all random objects sampled in advance (Tsyganov et al., 6 Aug 2025).

Taken together, these developments place NA-Hutch++ in a stable methodological niche. It is the non-adaptive Hutch++ architecture: low-rank capture plus stochastic residual correction, implemented through one-shot sketches rather than sequential query selection. Its theoretical identity is now sharply understood through near-optimal high-probability bounds, its practical strength lies in parallelizable and streaming settings, and its limitations are equally clear: when the low-rank component is too weak relative to the trace-relevant variance, the non-adaptive deflation step may add cost without delivering meaningful variance reduction (Jiang et al., 2021, Cotellucci et al., 2023).