Constant Matrix–Vector Multiplication

• CMVM is the computation of a fixed matrix–vector product where the matrix remains constant, enabling effective offline preprocessing and compression strategies.
• Techniques such as distributed arithmetic, Winograd–Gauss reduction, and FFT-coupled compression optimize multiplication by reducing multiplicative complexity and resource usage.
• Hardware implementations and data-structure approaches in CMVM lead to lower latency and energy consumption, critical for neural inference, digital signal processing, and numerical transforms.

Searching arXiv for recent and foundational papers on constant matrix-vector multiplication and related structured/hardware formulations. Constant matrix–vector multiplication (CMVM) is the computation of a matrix–vector product in a regime where the matrix is fixed across queries and only the input vector varies. In its most general form, the task is

$Y_{M\times 1}=A_{M\times N}X_{N\times 1},$

while neural-network formulations often write the same object as $\mathbf{y}=\mathbf{X}^T\mathbf{W}$ with $\mathbf{W}$ constant during inference. The fixed-coefficient assumption is the defining feature: it enables offline preprocessing, precomputation of coefficient combinations, compression of matrix structure, and specialized hardware datapaths that are not available for arbitrary online matrix–vector multiplication. Recent work treats CMVM from at least four complementary angles: arithmetic reduction for complex-valued hardware (Cariow et al., 2014), FFT-coupled compression for matrices defined by special functions (Terekhov, 2020), ADC-less in-memory distributed arithmetic for neural inference (Zeller et al., 2 Oct 2025), and data structures with subquadratic query time for structured matrices of low VC-dimension (Anand et al., 28 Feb 2025).

1. Definition and scope

In CMVM, the matrix is “constant” in the sense that its coefficients are fixed at design time or remain unchanged over a long sequence of queries. For neural-network inference, this means that weights are fixed after training and do not change during inference; the variable operand is the activation vector. For hardware-oriented complex CMVM, the matrix entries $a_{m,n}$ are constant complex numbers and the input vector entries $x_n$ are complex variables. For transform evaluation, the matrix is fixed once the nodes, basis family, and truncation order are fixed. For data-structural formulations, the matrix is preprocessed once and later queried with arbitrary vectors (Zeller et al., 2 Oct 2025).

The basic scalar output of CMVM is a constant-coefficient inner product. In the real-valued neural setting,

$Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$

so matrix–vector multiplication decomposes into $M$ constant vector–vector dot products, one per matrix column. In the complex-valued setting,

$$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$

and the design objective is to minimize multiplicative complexity under full parallelism. In special-function transforms, the matrix entries can be values such as $\cos(m\arccos x_n)$, $J_m^{(\alpha,\beta)}(x_n)$, or $\mathbf{y}=\mathbf{X}^T\mathbf{W}$0, and the constant-matrix assumption is precisely what makes one-time compression worthwhile. In structural-complexity formulations, the fixed matrix is the object being preprocessed so that future products $\mathbf{y}=\mathbf{X}^T\mathbf{W}$1 can be answered faster than naive dense multiplication when the matrix has exploitable combinatorial structure (Cariow et al., 2014, Terekhov, 2020, Anand et al., 28 Feb 2025).

A recurring practical interpretation is repeated use. The same weight matrix may be applied to many activations in inference, the same transform matrix to many coefficient vectors in numerical analysis, or the same graph-derived matrix to many query vectors in dynamic algorithms. CMVM therefore lies at the boundary between linear algebra, preprocessing, and specialized computation.

2. Arithmetic reformulations

One major CMVM strategy is to replace general multiplication by algebraic identities that exploit fixed coefficients. In distributed arithmetic (DA), a dot product

$\mathbf{y}=\mathbf{X}^T\mathbf{W}$2

is rewritten by expanding each variable input $\mathbf{y}=\mathbf{X}^T\mathbf{W}$3 in binary. For signed fixed-point inputs,

$\mathbf{y}=\mathbf{X}^T\mathbf{W}$4

which yields bit-plane subset sums

$\mathbf{y}=\mathbf{X}^T\mathbf{W}$5

Because the weights are constant, all $\mathbf{y}=\mathbf{X}^T\mathbf{W}$6 possible subset sums can be precomputed as a lookup table indexed by the $\mathbf{y}=\mathbf{X}^T\mathbf{W}$7-bit pattern $\mathbf{y}=\mathbf{X}^T\mathbf{W}$8. The DA recurrence is then implemented as shift-and-add. The ReRAM-based extension to matrix form stores, for each column $\mathbf{y}=\mathbf{X}^T\mathbf{W}$9,

$\mathbf{W}$0

and applies the same bit-slice address to all column-specific lookup tables in parallel, so that latency depends on input bit-width rather than the number of output columns $\mathbf{W}$1 (Zeller et al., 2 Oct 2025).

A second reformulation is the Winograd–Gauss reduction for complex-valued CMVM. Starting from

$\mathbf{W}$2

the method first applies Winograd’s inner-product formula at the complex level. For even $\mathbf{W}$3,

$\mathbf{W}$4

where

$\mathbf{W}$5

Since $\mathbf{W}$6 depends only on the fixed matrix, it can be precomputed offline. Winograd reduces the number of complex multiplications from $\mathbf{W}$7 to $\mathbf{W}$8. Each complex multiplication is then implemented using Gauss’s trick,

$\mathbf{W}$9

which uses $a_{m,n}$0 real multiplications instead of $a_{m,n}$1. The resulting fully parallel CMVM requires

$a_{m,n}$2

real two-input multipliers rather than $a_{m,n}$3, at the cost of a larger adder network. In the formulation without special one-input encoders, the adder count is $a_{m,n}$4 signed two-input adders plus $a_{m,n}$5 $a_{m,n}$6-input adders (Cariow et al., 2014).

These two arithmetic lines represent distinct CMVM philosophies. DA removes hard-wired multipliers by turning fixed coefficients into lookup-table contents. Winograd–Gauss reduces but does not eliminate multiplication, and is particularly natural for complex arithmetic in FPGA-style fully parallel datapaths.

3. Precomputation and compressed representations

A different CMVM paradigm arises when the fixed matrix is defined by special functions. The extra-components method targets matrices whose entries are samples of Chebyshev, trigonometric, Jacobi, Legendre, Gegenbauer, Laguerre, and related functions. Its central observation is that, after multiplication by a Kaiser window and a discrete Fourier transform, rows or columns of these matrices acquire a compact Fourier-domain sparsity pattern. The compressed matrix is written as

$a_{m,n}$7

where $a_{m,n}$8 is a diagonal window matrix and $a_{m,n}$9 is the unitary DFT. A matrix–vector product is then factored as

$x_n$0

This separates the computation into a diagonal scaling, an FFT, and a sparse multiplication by $x_n$1 (Terekhov, 2020).

The “extra-components” mechanism addresses the instability caused by $x_n$2, whose edge entries can become large. The method augments the matrix by $x_n$3 extra columns or rows, pads the input with zeros in the corresponding positions, and performs the compression on the augmented system. In the trigonometric case, the augmented matrix can be written as

$x_n$4

with an input vector padded by zeros on both sides. The large values of $x_n$5 are then multiplied by zeros at the artificial boundary locations, which stabilizes the computation (Terekhov, 2020).

The reported complexity is $x_n$6 for precomputation and $x_n$7 for each subsequent multiplication. For trigonometric matrices, Appendix A gives a faster precomputation route of

$x_n$8

with $x_n$9, by FFT-ing the Kaiser window once and evaluating only the relevant frequency components. The numerical experiments report that these procedures can decrease calculation time by several orders of magnitude compared with a conventional direct method of matrix–vector multiplication. In the Chebyshev case, target tolerance $Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$0 used bandwidth $Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$1 with $Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$2, while target tolerance $Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$3 used $Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$4 with $Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$5. For Jacobi transforms, block decomposition is used because negative polynomial degrees are not available; for time-domain Laguerre transforms, a two-dimensional compression

$Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$6

is applied (Terekhov, 2020).

This family of methods is CMVM in a strict numerical-analysis sense: the matrix is compressed once, stored in sparse FFT-coupled form, and then reused across many vectors. The efficiency gain comes not from low rank in the usual sense, but from Fourier localization after windowing.

4. Hardware realizations

Hardware-oriented CMVM exploits fixed coefficients at the architecture level. In the complex-valued FPGA formulation, the datapath is organized into a pre-addition stage for Winograd pairings, Gauss-based complex multiplication blocks, and a post-addition accumulation stage. Matrix coefficients and precomputed constants $Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$7 are stored in ROM or hard-wired, and the data-flow diagrams are explicitly given for the $Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$8 case. The method is intended for fully parallel implementations on FPGA families such as Xilinx Spartan-3, Altera Cyclone-III, and Stratix-V, where embedded multipliers are limited and adders are comparatively cheaper. The paper does not report concrete FPGA synthesis results, but its principal claim is the reduction from $Y_j=\sum_{i=1}^{N}X_iW_{ij},\qquad j=1,\dots,M,$9 real multipliers to $M$0 in a regular, pipeline-friendly architecture (Cariow et al., 2014).

The ReRAM in-memory realization of DA is more radical. Here the matrix coefficients are transformed into lookup-table contents stored in 1T–1R ReRAM processing memory arrays (PMAs). The cells store digital bits corresponding to precomputed subset sums, so the memory functions as a ROM for DA rather than an analog crossbar. For the $M$1 matrix that represents the first convolutional layer of LeNet-5, the $M$2-element input vector is partitioned into groups of $M$3, $M$4, and $M$5 elements, mapped to PMA-1 $M$6, PMA-2 $M$7, and PMA-3 $M$8. Each cycle reads three partial sums, combines them with $M$9-bit and $$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$0-bit adders, and feeds the result into a $$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$1-bit shift-and-add accumulator over $$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$2 input bit-cycles (Zeller et al., 2 Oct 2025).

The reported timing is $$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$3 for the first cycle, $$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$4 for each of the next seven cycles due to overlapped sensing and precharge, and less than $$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$5 for the final $$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$6-bit addition, giving

$$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$7

The energy per VMM is $$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$8 excluding one-time precomputation, and the amortized total used for comparison is

$$a_{m,n}=a_{m,n}^{(r)}+ja_{m,n}^{(i)},\quad x_n=x_n^{(r)}+jx_n^{(i)},\quad y_m=y_m^{(r)}+jy_m^{(i)},$$9

Against a bit-slicing ReRAM baseline for the same $\cos(m\arccos x_n)$0 multiplication, the comparison is $\cos(m\arccos x_n)$1 versus $\cos(m\arccos x_n)$2 in latency and $\cos(m\arccos x_n)$3 versus $\cos(m\arccos x_n)$4 in energy, i.e. $\cos(m\arccos x_n)$5 lower latency and about $\cos(m\arccos x_n)$6 lower energy. The area trade-off is explicit: the bit-slicing design uses $\cos(m\arccos x_n)$7 memory cells $\cos(m\arccos x_n)$8 transistors $\cos(m\arccos x_n)$9 passive resistors, whereas the DA design uses $J_m^{(\alpha,\beta)}(x_n)$0 memory cells $J_m^{(\alpha,\beta)}(x_n)$1 transistors, with no passive resistors and no ADC/DAC (Zeller et al., 2 Oct 2025).

The decisive architectural distinction is that DA removes both multipliers and multi-bit data conversion from the critical computation path. The ReRAM system uses comparator-based sense amplifiers with about $J_m^{(\alpha,\beta)}(x_n)$2 per READ rather than ADCs, and the computation path is entirely digital after binary sensing. This makes the design especially suitable for fixed-weight inference workloads in which the one-time cost of writing lookup tables is amortized across many reads (Zeller et al., 2 Oct 2025).

5. Structural complexity and preprocessing-based CMVM

CMVM can also be formalized as a data-structure problem: preprocess a fixed matrix $J_m^{(\alpha,\beta)}(x_n)$3, then answer queries that return $J_m^{(\alpha,\beta)}(x_n)$4 for arbitrary vectors $J_m^{(\alpha,\beta)}(x_n)$5. For arbitrary dense matrices, classical worst-case and average-case results still indicate essentially quadratic query time. The structured alternative introduced for Boolean matrices is to parameterize the matrix by the VC-dimension of the set system induced by its rows. If $J_m^{(\alpha,\beta)}(x_n)$6, then $J_m^{(\alpha,\beta)}(x_n)$7 is the VC-dimension of the range space $J_m^{(\alpha,\beta)}(x_n)$8 (Anand et al., 28 Feb 2025).

The main static theorem states that if $J_m^{(\alpha,\beta)}(x_n)$9 has corrupted VC-dimension $\mathbf{y}=\mathbf{X}^T\mathbf{W}$00, then after $\mathbf{y}=\mathbf{X}^T\mathbf{W}$01-time preprocessing there is a data structure that computes $\mathbf{y}=\mathbf{X}^T\mathbf{W}$02 for any $\mathbf{y}=\mathbf{X}^T\mathbf{W}$03 in

$\mathbf{y}=\mathbf{X}^T\mathbf{W}$04

time, with high probability. For square matrices this gives $\mathbf{y}=\mathbf{X}^T\mathbf{W}$05 query time after $\mathbf{y}=\mathbf{X}^T\mathbf{W}$06 preprocessing. The “corrupted” condition means that $\mathbf{y}=\mathbf{X}^T\mathbf{W}$07, where $\mathbf{y}=\mathbf{X}^T\mathbf{W}$08 has VC-dimension $\mathbf{y}=\mathbf{X}^T\mathbf{W}$09 and each row of $\mathbf{y}=\mathbf{X}^T\mathbf{W}$10 has at most $\mathbf{y}=\mathbf{X}^T\mathbf{W}$11 nonzero entries, so the guarantees survive adversarial perturbations of a subquadratic number of entries. If $\mathbf{y}=\mathbf{X}^T\mathbf{W}$12 has corrupted VC-dimension $\mathbf{y}=\mathbf{X}^T\mathbf{W}$13, a symmetric bound $\mathbf{y}=\mathbf{X}^T\mathbf{W}$14 is available, and one can take the better of the two (Anand et al., 28 Feb 2025).

The technique is differential compression via a $\mathbf{y}=\mathbf{X}^T\mathbf{W}$15-labeled spanning tree on the columns or rows of the matrix. If $\mathbf{y}=\mathbf{X}^T\mathbf{W}$16 is such a tree and each edge label is $\mathbf{y}=\mathbf{X}^T\mathbf{W}$17, its weight is

$\mathbf{y}=\mathbf{X}^T\mathbf{W}$18

Given this representation, $\mathbf{y}=\mathbf{X}^T\mathbf{W}$19 can be computed in

$\mathbf{y}=\mathbf{X}^T\mathbf{W}$20

time. The key structural theorem shows that for matrices of corrupted VC-dimension $\mathbf{y}=\mathbf{X}^T\mathbf{W}$21, the minimum-spanning-tree weight in Hamming space is at most

$\mathbf{y}=\mathbf{X}^T\mathbf{W}$22

which yields the subquadratic query algorithm. The framework extends dynamically: row updates take $\mathbf{y}=\mathbf{X}^T\mathbf{W}$23, column updates $\mathbf{y}=\mathbf{X}^T\mathbf{W}$24, and queries retain the same asymptotic form with $\mathbf{y}=\mathbf{X}^T\mathbf{W}$25 equal to the largest corrupted VC-dimension over the update history. For non-Boolean matrices, a parallel result uses Pollard pseudodimension: if the pseudodimension is $\mathbf{y}=\mathbf{X}^T\mathbf{W}$26 and the number of thresholds is $\mathbf{y}=\mathbf{X}^T\mathbf{W}$27, preprocessing is $\mathbf{y}=\mathbf{X}^T\mathbf{W}$28 and query time is $\mathbf{y}=\mathbf{X}^T\mathbf{W}$29 (Anand et al., 28 Feb 2025).

This line of work clarifies an important conceptual point: CMVM does not in general imply constant-time queries. Even in the most favorable structured regimes, the output itself has size $\mathbf{y}=\mathbf{X}^T\mathbf{W}$30, so $\mathbf{y}=\mathbf{X}^T\mathbf{W}$31 is a natural lower limit in the standard RAM model. What preprocessing can achieve is subquadratic rather than constant asymptotic query time for broad structured matrix classes (Anand et al., 28 Feb 2025).

6. Applications, trade-offs, and limitations

CMVM appears in several technically distinct application families. In neural inference, vector–matrix multiplication is described as a fundamental and frequently required computation, and the fixed-weight assumption is intrinsic to inference rather than training. The LeNet-5 CONV1 mapping uses a $\mathbf{y}=\mathbf{X}^T\mathbf{W}$32 fixed matrix, a $\mathbf{y}=\mathbf{X}^T\mathbf{W}$33 padded input, and $\mathbf{y}=\mathbf{X}^T\mathbf{W}$34 VMMs per inference. In hardware-intensive complex arithmetic, CMVM is central in digital signal processing, FIR filters, filter banks, communication systems such as MIMO processing and equalizers, image and video processing, and linear algebra kernels in high-performance computing. In numerical transforms, fixed matrices arise from Chebyshev, Jacobi, Legendre, Gegenbauer, and Laguerre evaluations. In graph algorithms, the preprocessing view of CMVM yields subquadratic upper bounds for dynamic Laplacian solvers, effective resistance, triangle detection, approximate single-source shortest paths, and approximate $\mathbf{y}=\mathbf{X}^T\mathbf{W}$35-center under structural assumptions (Zeller et al., 2 Oct 2025, Cariow et al., 2014, Terekhov, 2020, Anand et al., 28 Feb 2025).

The principal trade-offs differ by formulation. DA-based in-memory CMVM replaces multipliers by lookup tables and shift-and-add logic, eliminates ADCs and DACs, and obtains lower latency and energy, but its memory footprint grows exponentially with the group size used for lookup-table construction. In the $\mathbf{y}=\mathbf{X}^T\mathbf{W}$36 case, the three PMAs contain $\mathbf{y}=\mathbf{X}^T\mathbf{W}$37 memory cells, much larger than raw weight storage, although this is a one-time cost. The paper also states that the DA computation is exact under fixed-point arithmetic; any accuracy impact comes from quantization, and explicit accuracy numbers for the quantized LeNet-5 case are not provided (Zeller et al., 2 Oct 2025).

The Winograd–Gauss complex CMVM method reduces multipliers substantially, but it increases the number of adders and therefore logic utilization and routing complexity. It assumes even $\mathbf{y}=\mathbf{X}^T\mathbf{W}$38, with odd-length vectors handled by reduction to an even-length case. Its benefit is largest when multipliers are the dominant constrained resource, as on many FPGA and ASIC targets (Cariow et al., 2014).

The extra-components method offers $\mathbf{y}=\mathbf{X}^T\mathbf{W}$39 execution time after precomputation, but the precomputation can be heavy for Jacobi and Laguerre cases, and the method is worthwhile primarily when the same matrix is used repeatedly. It is effective for oscillatory special-function kernels and less effective for some non-oscillatory kernels with complex local singularities, where wavelet-based compression can be better. Its accuracy and bandwidth are controlled by the thresholds $\mathbf{y}=\mathbf{X}^T\mathbf{W}$40 and $\mathbf{y}=\mathbf{X}^T\mathbf{W}$41, the window parameter $\mathbf{y}=\mathbf{X}^T\mathbf{W}$42, and the number of extra components $\mathbf{y}=\mathbf{X}^T\mathbf{W}$43 (Terekhov, 2020).

The VC-dimension framework provides a theoretical explanation for why some CMVM instances admit subquadratic query time after preprocessing, but it does not establish lower bounds in the structured setting. It leaves open whether the exponent $\mathbf{y}=\mathbf{X}^T\mathbf{W}$44 is optimal for fixed $\mathbf{y}=\mathbf{X}^T\mathbf{W}$45, and it identifies improvement of the threshold factor $\mathbf{y}=\mathbf{X}^T\mathbf{W}$46 in the non-Boolean pseudodimension bound as an open direction (Anand et al., 28 Feb 2025).

Across these lines, one misconception is consistently rejected by the technical literature: “constant matrix” means fixed coefficients across queries, not trivial computation. Fixedness can be exploited through precomputation, compression, or hardware specialization, but the resulting algorithms inhabit different points in the design space. Some trade memory for energy and converter elimination, some trade adders for multipliers, some trade preprocessing for near-FFT execution, and some trade structural assumptions for subquadratic online complexity. CMVM is therefore best understood not as a single algorithmic trick but as a family of fixed-coefficient linear-algebra regimes in which preprocessing is the central resource.