Hardware-Efficient Measurement Transformation

• Hardware-Efficient Measurement Transformation Framework is a design paradigm that converts measurement tasks into optimized formats for processors like GPUs and quantum devices.
• It employs methods such as Fast Walsh-Hadamard Transforms, learnable rotations with diagonal scaling, and integer-only mappings to align computation with hardware strengths.
• Applications include GPU inference, low-precision LLM quantization, quantum error mitigation, and spectral estimation, leading to improvements in speed, efficiency, and accuracy.

A hardware-efficient measurement transformation framework is a class of techniques that rewrites a measurement, observable, signal, or weight/activation representation into a form better matched to a target execution substrate while preserving the quantity of interest or the downstream task objective. Across recent work, this idea appears in GPU kernels for Fast Walsh-Hadamard transforms, sub-1-bit LLM quantization, model-free quantum measurement error mitigation, native topological readout on qubit hardware, classical-shadow-based eigensolvers, and integer-only dual-manifold mappings. In each case, the transformation is not merely algebraic: it is chosen so that the dominant costs shift from an unfavorable bottleneck—dense matrix multiplication, sparse-mask management, high-weight Pauli measurement, controlled operations, or floating-point arithmetic—into hardware-friendly primitives such as Tensor Core MMA, Hadamard rotations, XOR+POPCNT, shallow Clifford circuits, or compare-and-add integer loops (Agarwal et al., 2024, Gu et al., 24 May 2025, Xu et al., 22 Sep 2025, Ayeni, 25 May 2026, Shen et al., 2024, Kopp, 11 Jun 2026).

1. Scope and defining pattern

The papers grouped under this theme address different hardware targets, but they share a common structure: an original measurement task is recast into an equivalent or approximately equivalent transformed task whose execution path is simpler, lower-overhead, or more statistically efficient on the relevant platform. In GPU inference, the transformed primitive is the Fast Walsh-Hadamard Transform (FWHT), which provides orthogonal mixing with $\mathcal{O}(N\log_2 N)$ complexity and no stored transform matrix. In LLM binarization, the transformed domain is defined by a learnable diagonal scaling and orthogonal rotation before sign quantization, followed by binary codebook clustering. In qubit systems, measurement compilation either changes the operator basis to a native fusion basis or lowers the effective Pauli weight before twirling-based mitigation. In classical-shadow eigensolvers, randomized measurements transform many dynamical correlators into a shared signal subspace. In integer-only edge inference, an 8-bit bounded transformation matrix converts raw inputs into sign-voted manifold activations (Agarwal et al., 2024, Gu et al., 24 May 2025, Xu et al., 22 Sep 2025, Ayeni, 25 May 2026, Shen et al., 2024, Kopp, 11 Jun 2026).

Domain	Transformation mechanism	Hardware objective
GPU FWHT	Tensor Core accelerated Hadamard tiles	Reduce compute and data-exchange bottlenecks
LLM quantization	Learnable $\Lambda$, orthogonal $R$, Hadamard-constrained sublayers, binary codebook	Eliminate sparse masks and enable standard hardware inference
NISQ readout	Native fusion-basis compilation or grouped Pauli reconstruction	Optimize covariance-aware MSE under shot and compilation constraints
MF-MEM	Low-weight effective Pauli operators via linear-depth circuits	Reduce SB-PT twirling cost to $\mathcal{O}(4^\tau)$
Spectral estimation	Classical-shadow scrambling plus DMD	Replace controlled tests and predict many observables
Integer edge inference	8-bit Z-matrix sign-voting with thresholds	Remove floating-point multipliers and favor cache-friendly access

A plausible implication is that “hardware-efficient measurement transformation” is best understood not as a single algorithm, but as a design pattern: preserve the target statistic while moving its implementation into a basis, datatype, operator support, or memory layout that the hardware executes well.

2. Mathematical structure of measurement transformation

Several of the frameworks make the transformation explicit as a linear or orthogonal map. For FWHT-based systems, the Hadamard matrix is defined recursively by $H_1=[1]$ and

$$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$

with transform $y=H_Nx$ or normalized transform $y=\frac{1}{\sqrt{N}}H_Nx$. The stagewise butterfly is

$a'=a+b,\qquad b'=a-b,$

and the asymptotic complexity is $\mathcal{O}(N\log_2 N)$. The significance of this formulation in measurement frameworks is that orthogonal mixing, randomized projections, sketching, preconditioning, compressive sensing, and quantization-friendly outlier redistribution can be implemented without materializing a dense matrix (Agarwal et al., 2024).

In BTC-LLM, the transformed forward path for a layer with frozen weights $\Lambda$0 is

$\Lambda$1

with objective

$\Lambda$2

Here $\Lambda$3 is diagonal and invertible, $\Lambda$4 is orthogonal with $\Lambda$5 and $\Lambda$6, and the purpose of the transformed domain is to suppress outliers and improve layer incoherence before binarization. The same work then maps binary vectors to codebook indices by a Hamming-distance objective, exploiting

$\Lambda$7

which directly aligns the representation with bitwise hardware (Gu et al., 24 May 2025).

In subsystem-balanced Pauli twirling, the core transformation is operator-support reduction:

$\Lambda$8

where a nearest-neighbor Clifford circuit lowers the effective Pauli weight before twirling. In MODMD, the transformation acts on measurement data rather than on the operator alone: shadows estimate many low-rank observables simultaneously, with sample complexity

$\Lambda$9

and the resulting multi-observable time series is embedded into a block Hankel structure for DMD. In the 8-bit dual-manifold mapping, the transformed score is

$R$0

with $R$1 and $R$2, thereby replacing multiplication by thresholding, sign extraction, and integer accumulation (Xu et al., 22 Sep 2025, Shen et al., 2024, Kopp, 11 Jun 2026).

3. Tensor-Core Hadamard kernels and low-precision LLM inference

"HadaCore" optimizes a modified FWHT for Tensor Cores on modern NVIDIA GPUs while preserving the recursive structure and asymptotic runtime complexity of the original FWHT. Its base case is a $R$3 Hadamard handled by Tensor Core MMA instructions, with one $R$4-by-$R$5 multiplication built from two $R$6-by-$R$7 MMA operations. The implementation aggregates data into 256-element tiles per warp, stages intermediate results through shared memory, uses register-level transposes, and relies on warp shuffles for sizes 512–2048 and for redistribution at sizes $R$8. This hardware-aware decomposition is intended to reduce synchronization, indexing overhead, and data-exchange bottlenecks relative to CUDA-core butterfly kernels (Agarwal et al., 2024).

The reported performance gains are conditional rather than uniform. On A100, the kernel achieves 1.1–1.4× typical speedups with a peak up to 3.5×; on H100, it achieves 1.0–1.3× typical speedups with a peak up to 3.6×. Peak gains appear when large batches or element counts are used and when sizes align well with $R$9 tiling, while size 512 shows smaller gains because of the first cross-256 synchronization and relatively higher shared-memory shuffling cost, and size 8K shows lower speedup because it requires an additional full $\mathcal{O}(4^\tau)$0 tiling iteration compared to 4K. The paper also reports numerical accuracy in FP16 and BF16, and in an end-to-end Llama-3.1 8B run with FP8 attention the average 5-shot MMLU values were 65.38 for the FP16 baseline, 64.40 for FP8 attention without rotation, 65.45 for FP8 attention with the Dao AI Lab FWHT rotation, and 65.09 for FP8 attention with HadaCore FWHT (Agarwal et al., 2024).

BTC-LLM uses the same general principle in a different layer of the stack. It compresses LLM weights below 1 bit per parameter without sparse masks by combining a learnable invertible transformation with binary pattern clustering. The learned transformation optimizes a diagonal scaling $\mathcal{O}(4^\tau)$1 and orthogonal rotation $\mathcal{O}(4^\tau)$2 while keeping $\mathcal{O}(4^\tau)$3 frozen; after transformation, weights are binarized and reshaped into local vectors for binary codebook clustering. At inference, centroids are recovered by index lookup, row scales and biases are reconstructed, and the learned transformation is fused back into the weights whenever possible. For attention Q/K and FFN down-projection, Hadamard transforms are used to remain hardware-friendly, so the scheme avoids sparse gathers and scatters and instead uses dense lookups and XOR+POPCNT-compatible operations on standard GPUs, CPUs, and NPUs (Gu et al., 24 May 2025).

The quantitative results place the transformation stage at the center of the compression-quality trade-off. On WikiText2, BTC-LLM reports perplexity 6.06 for LLaMA-2-7B at 1.11 bits, 6.07 at 0.90 bits, 6.60 at 0.80 bits, and 11.02 at 0.70 bits; at 0.80 bits, LLaMA-2-13B reaches average zero-shot accuracy 61.91% versus 53.85% for STBLLM. For LLaMA-2-7B memory, FP16 13.48 GB becomes 1.70 GB at 0.7-bit, which the paper describes as an approximately 8× reduction, and the codebook overhead is reported as 0.000022% at 0.7-bit. Ablations show the progression “no transform: 8.00 ppl; Hadamard: 6.95; learned $\mathcal{O}(4^\tau)$4 only: 6.82; learned $\mathcal{O}(4^\tau)$5 + diagonal $\mathcal{O}(4^\tau)$6: 6.60,” indicating that the transformation stage is not an auxiliary detail but a primary accuracy determinant under extreme quantization (Gu et al., 24 May 2025).

4. Quantum measurement compilation, native readout, and model-free mitigation

On qubit hardware, measurement transformation appears in two distinct but related forms: basis changes that align observables with native readout channels, and circuit-level rewritings that lower observable weight before mitigation. In the Fibonacci-chain benchmark, the Hamiltonian contains nearest-neighbor fusion terms and next-nearest-neighbor braid-plus-fusion terms, and the comparison is between native fusion-basis readout (FR) and a grouped Pauli basis baseline using qubit-wise commuting groups (PS-QWC). FR measures each local term in a problem-adapted basis by appending a short unitary $\mathcal{O}(4^\tau)$7 such that $\mathcal{O}(4^\tau)$8; for BF4, $\mathcal{O}(4^\tau)$9. The benchmark evaluates the full energy estimator with covariance-aware mean-squared error,

$H_1=[1]$0

including a sampling covariance term $H_1=[1]$1, so measurement transformation is assessed jointly by sampling efficiency and compilation-induced bias (Ayeni, 25 May 2026).

The central conclusion is explicitly non-universal. For digital Floquet circuits, FR wins 72/96 cells in empirical MSE and 96/96 in mean sampling variance in the noiseless setting, and on hardware FR wins 71/96 in empirical MSE and 96/96 in mean sampling variance, with fitted crossovers inside $H_1=[1]$2 in 4/24 scaling cells and median $H_1=[1]$3. For optimized-state VQE, FR wins 15/16 in empirical MSE and 16/16 in sampling variance in the noiseless setting, but on hardware PS wins 15/16 in empirical MSE while FR still wins 16/16 in sampling variance; the fitted crossovers occur in 3/4 scaling cells with median $H_1=[1]$4. The paper attributes this reversal to compilation overhead: in shallow VQE circuits the FR measurement layer can be large relative to state preparation, whereas in deep Floquet circuits the additional layer is comparatively small (Ayeni, 25 May 2026).

"Efficient Measurement Error Mitigation with Subsystem-Balanced Pauli Twirling" addresses a different quantum bottleneck: the sampling overhead of model-free measurement error mitigation. For a weight-$H_1=[1]$5 Pauli observable, subsystem-balanced Pauli twirling (SB-PT) uses a twirling set balanced on the measured subsystem and removes all independent error components using only $H_1=[1]$6 random circuits. To extend this efficiency to dense observables, the paper introduces a hardware-efficient measurement transformation that converts a high-weight $H_1=[1]$7 into a low-weight effective operator via linear-depth nearest-neighbor circuits,

$H_1=[1]$8

using weight-reduction and location-shift gadgets built from CX chains. Unified twirling is then applied in the effective basis so that the circuit noise introduced by the transformation and the native measurement noise are mitigated together (Xu et al., 22 Sep 2025).

The reported gains are substantial but also conditional. Extensive numerical simulations show a greater than 16-fold improvement in sampling efficiency over conventional random twirling. The benefits are strongest for sparse observables or for dense observables after measurement transformation; for example, MT(sub) with effective weight $H_1=[1]$9 and $$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$0 matched or exceeded the accuracy of MF or MT(rnd) at $$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$1. At the same time, the paper notes that very dense observables without measurement transformation still require $$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$2 circuits, and that highly coherent or strongly correlated non-TPN noise outside the effective support may reduce the benefit (Xu et al., 22 Sep 2025).

5. Measurement transformation as randomized observation in spectral estimation

MODMD extends the measurement-transformation idea from single observables to entire dynamical signal spaces. It combines observable dynamic mode decomposition with classical shadow tomography so that, for discrete times $$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$3, one estimates many signals

$$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$4

from a single shallow scrambling circuit per time point and classical post-processing. The resulting multi-observable vector $$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$5 populates a block Hankel structure, and DMD then recovers eigenphases $$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$6 and the associated energies. The transformation is therefore twofold: randomized measurements replace direct observable-specific circuits, and the recovered signal subspace replaces explicit spectral filtering (Shen et al., 2024).

A central feature of MODMD is the replacement of Hadamard tests and controlled operations by shadow estimators for low-rank observables. With the ancilla-assisted observable

$$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$7

the protocol estimates $$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$8 from classical shadows using the inverse shadow channel $$H_{2n}= \begin{bmatrix} H_n & H_n \ H_n & -H_n \end{bmatrix},$$9. The paper states that naïve measurement of $y=H_Nx$0 via Hadamard tests scales as $y=H_Nx$1 shots per time point, whereas classical shadows reduce this to $y=H_Nx$2 with shallow circuits, giving an exponential “predict many” gain when $y=H_Nx$3 is large (Shen et al., 2024).

The framework also comes with spectral guarantees. In the ideal case, the spectral error scales as $y=H_Nx$4, where $y=H_Nx$5 is the relevant spectral gap and $y=H_Nx$6. Empirically, the paper reports that MODMD with $y=H_Nx$7 random 1-local Pauli observables on a transverse-field Ising model with $y=H_Nx$8 rapidly converges to the first four eigenenergies, and that on LiH in STO-3G the method accurately recovers low-lying energies from an observable pool selected from medium-weight Hamiltonian Pauli terms. This suggests that, in this context, measurement transformation is not only a readout optimization but also a data-modeling strategy that enlarges the effective signal subspace available to a near-term device (Shen et al., 2024).

6. Integer-only dual-manifold mappings and bounded transformation matrices

The 8-bit dual-manifold framework provides a markedly different instantiation of the same theme. It defines a Spatial Manifold with $y=H_Nx$9 nodes and a Gabor-pooled Structural Manifold with $y=\frac{1}{\sqrt{N}}H_Nx$0 nodes, coupled by an integer Z-matrix

$y=\frac{1}{\sqrt{N}}H_Nx$1

Inputs are normalized into int8, accumulators are int16, and inference uses sign-voting and thresholding rather than multiplication:

$y=\frac{1}{\sqrt{N}}H_Nx$2

with $y=\frac{1}{\sqrt{N}}H_Nx$3 and $y=\frac{1}{\sqrt{N}}H_Nx$4. The matrix is stored column-major by input index so that the inner loop traverses contiguous memory, enabling cache-friendly pointer offsets and bitwise sign extraction from the most significant bit (Kopp, 11 Jun 2026).

The framework’s hardware claims are stated in terms of primitive operations and memory layout. For each active input and channel, inference performs an absolute compare on $y=\frac{1}{\sqrt{N}}H_Nx$5, an input-activity compare on $y=\frac{1}{\sqrt{N}}H_Nx$6, sign extraction via bit shift, and a conditional add or subtract on an int16 accumulator. The worst-case event count is $y=\frac{1}{\sqrt{N}}H_Nx$7 compare-and-optional-add events; under 90% truncation sparsity and typical input gating with only approximately 10% of inputs active, this drops to approximately 3.35M events per inference window. The Z matrix occupies approximately 32 MiB, while the input buffer is 8 KiB and the accumulator buffer is approximately 8 KiB (Kopp, 11 Jun 2026).

The same work also frames measurement transformation as a robustness mechanism. A global or per-channel scaling factor compensates for missing votes:

$y=\frac{1}{\sqrt{N}}H_Nx$8

or, under node loss,

$y=\frac{1}{\sqrt{N}}H_Nx$9

The paper reports near-perfect reconstruction under 90% truncation sparsity and 20% random node destruction, and gives the combined scaling factor $a'=a+b,\qquad b'=a-b,$0 for that case. The update rule, when enabled, remains strictly local and integer-bounded:

$a'=a+b,\qquad b'=a-b,$1

with $a'=a+b,\qquad b'=a-b,$2 and optional Bernoulli noise injection. In this instance, “measurement transformation” denotes a multiplier-free remapping of raw measurements into a sparse manifold code that is explicitly constrained by int8 hardware (Kopp, 11 Jun 2026).

7. Trade-offs, limitations, and recurring points of contention

A recurring misconception is that a hardware-efficient transformation is automatically superior to a direct measurement or direct computation path. The cited work does not support that claim. In the Fibonacci-chain benchmark there is “not a uniform best method across both problems”: native fusion readout lowers covariance-aware sampling variance, but grouped Pauli measurement can yield lower realized MSE on shallow VQE hardware because the native measurement layers are significantly deeper. HadaCore also shows non-uniform gains, with smaller speedup at size 512 and lower speedup at size 8K, and the H100 average gain is smaller than on A100 because Hopper behavior differs in compute-to-bandwidth ratio and load instructions (Ayeni, 25 May 2026, Agarwal et al., 2024).

A second recurring issue is that transformation stages introduce new hyperparameters or hardware assumptions. BTC-LLM is sensitive to vector length $a'=a+b,\qquad b'=a-b,$3 and codebook size $a'=a+b,\qquad b'=a-b,$4, and the paper notes that if $a'=a+b,\qquad b'=a-b,$5 deviates from orthogonality, inversion and fusion degrade; a few sublayers require Hadamard transforms rather than generic $a'=a+b,\qquad b'=a-b,$6 merging, and distribution shift across tasks may require re-optimizing $a'=a+b,\qquad b'=a-b,$7 and $a'=a+b,\qquad b'=a-b,$8. SB-PT without measurement transformation remains expensive for dense observables, and measurement transformation itself adds CX depth, so devices with low two-qubit fidelity may favor effective weights $a'=a+b,\qquad b'=a-b,$9 rather than maximal compression. MODMD assumes a suitable time step $\mathcal{O}(N\log_2 N)$0, a reference state with nonvanishing overlap with target modes, and a shadow ensemble that forms a good frame. The 8-bit dual-manifold mapping, while multiplier-free, still carries a large Z-matrix footprint of approximately 32 MiB and offers only coarse binary or small-integer outputs unless the score vectors are retained (Gu et al., 24 May 2025, Xu et al., 22 Sep 2025, Shen et al., 2024, Kopp, 11 Jun 2026).

A plausible unifying interpretation is that the main design variable is not simply “more transformation” or “less transformation,” but where the transformation relocates complexity. The strongest results arise when the transformed representation aligns with the dominant accelerator primitives of the platform: Tensor Core MMA for Hadamard mixing, XOR+POPCNT and dense lookup for sub-1-bit inference, low-support native projectors or low-weight Pauli operators for quantum readout, shallow scrambling for classical-shadow estimation, and compare-plus-accumulate loops for integer-only inference. Where that alignment fails, the overhead of the transformation can dominate the intended gain (Agarwal et al., 2024, Gu et al., 24 May 2025, Xu et al., 22 Sep 2025, Ayeni, 25 May 2026, Shen et al., 2024, Kopp, 11 Jun 2026).