Matrix-Vector Multiplication and Reduction

• MVMR is a computational paradigm that combines classical and generalized matrix-vector operations, enabling efficient data reduction and versatile analyses.
• It leverages semiring formulations and structured operator generalizations to support dynamic programming, spectral methods, and graph-based algorithms.
• Applications span scalable parallel processing, distributed computing, and advanced hardware implementations including in-memory, optical, and quantum architectures.

Matrix-Vector Multiplication and Reduction (MVMR), encompassing both classical and generalized matrix-vector operations, underpins a vast array of computational, scientific, and engineering domains. This concept unifies the processes of multiplying a matrix (or structured linear operator) by a vector and reducing, accumulating, or combining the partial results according to the algebraic structure of the underlying problem. Recent advances span theory (fine-grained lower/upper bounds), architectures (in-memory, optical, quantum, and compressed), parallel and distributed strategies, and application-driven formulations. The sections below provide a comprehensive technical survey.

1. Core Definitions and Algebraic Formulation

Matrix-Vector Multiplication and Reduction encompasses computations of the form

$$y = Mx, \quad \text{or} \quad y_i = \bigoplus_{j} (M_{ij} \otimes x_j)$$

where $M$ is a matrix (not necessarily dense or real-valued), $x$ is a vector, $\otimes$ and $\oplus$ are binary operations (potentially not standard multiplication and addition), and $y$ is the reduced result, possibly followed by an assign or post-processing step. This generalized semiring approach, as exemplified by the GIM-V model, accommodates classic algebraic (real/complex), Boolean, and min-plus systems, capturing PageRank, shortest paths, and other graph algorithms (Park et al., 2017).

Key properties of $(S, \otimes, \oplus)$ must include associativity, with distributivity and commutativity as warranted, enabling a broad class of generalized MVMR workloads, including dynamic programming, spectral methods, and iterative updates.

2. Computational Paradigms and Algorithmic Frameworks

Online and Fine-Grained Complexity

The Online Boolean Matrix-Vector Multiplication (OMV) paradigm asks for the sequential processing of a stream of query vectors $v_1, \ldots, v_t$ with a pre-fixed $n\times n$ Boolean matrix $M$, computing $M$0 (in the Boolean semiring) before $M$1 is seen. Classical combinatorial OMV algorithms achieved $M$2 total time, with the OMV conjecture positing no $M$3 time randomized algorithm for any $M$4 (Larsen et al., 2016). This conjecture formed the basis of conditional barriers in dynamic and data-structure query lower bounds.

The breakthrough of (Larsen et al., 2016) leverages reductions from online vector-matrix-vector queries to the orthogonal vectors (OV) problem, which in turn are solved via explicit small matrix–matrix multiplications, yielding randomized OMV in $M$5 total time and amortized $M$6 per query after initial rounds. A further cell-probe construction achieves $M$7 probes which eliminates purely information-theoretic lower bound approaches.

Structured Matrices and Practical Complexity Gaps

Theoretical $M$8 lower bounds are circumvented in practice for highly structured matrices. (Anand et al., 28 Feb 2025) shows that when the matrix $M$9 over $x$0 has VC-dimension $x$1, the query time for $x$2 can be reduced to $x$3 after $x$4 preprocessing, even with adversarial corruption in a subquadratic number of entries. The algorithm exploits spanning-tree differential compression (“mailman” method) in Hamming space, and Welzl-type crossing number bounds on VC-dimension, explaining the empirical success of fast MVMR routines for structured real-world datasets.

Distributed, Parallel, and Lossless Compressed Methods

For unstructured extraordinarily large systems, scalable strategies are essential:

• Nonzero-partitioned approach (partitioning by nonzeros, not rows/columns) maintains perfect flop balance across processors and robust communication characteristics, systematically constructing “overlap zones” to handle shared vector entries and ensuring only $x$5 additional communicator setup with no global decompositions required (Eckstein et al., 2018).
• Black-box kernel MVMR for fast kernel summation leverages hierarchical low-rank expansions (e.g., FMM) to reduce computational complexity from $x$6 to $x$7 for translation-invariant, non-oscillatory kernels, with OpenMP-parallelism and only a single vector reduction phase required (Wang et al., 2019).

Lossless grammar-compressed MVMR operates directly on a compressed representation $x$8 of $x$9, matching space and time to the $\otimes$0-th order entropy $\otimes$1 of the matrix—enabling space and run-time proportional to the compressed form and outperforming general-purpose compressors such as xz/gzip, and compressed linear algebra (CLA) libraries (Ferragina et al., 2022).

3. Hardware Architectures and Specialized Implementations

Multiplier-Free and In-Memory MVMR

Distributed Arithmetic (DA) replaces traditional MAC-based matrix-vector multipliers with LUT- and shift-add architectures, particularly effective for constant-weight matrices in in-memory (ReRAM) fabrics (Zeller et al., 2 Oct 2025). The DA scheme eliminates power-hungry ADCs and multipliers, trading LUT and peripheral circuitry for significantly lower area and energy, achieving $\otimes$2 lower latency and $\otimes$3 lower energy than bit-sliced in-memory VMM. The organization employs chunking high-dimensional vectors into $\otimes$4-bit groups for tractable LUT size.

Complex Arithmetic Optimization

For FPGA/ASICs and DSP pipelines, Winograd-based inner-product restructuring combined with Gauss's three-multiplier complex multiplication enables constant complex matrix–vector products with only $\otimes$5 real multipliers and $\otimes$6 two-input real adders for $\otimes$7 matrices, a significant reduction from the naïve $\otimes$8 multipliers (Cariow et al., 2014). The pipelined and block-structured algorithm supports high-throughput implementations for communication and signal processing.

Polynomial and Cryptographic Domains

In the context of post-quantum cryptographic schemes (e.g., Kyber), KyberMat splits each input polynomial into polyphase (even/odd) components, applies NTTs, and exploits sub-structure sharing to reduce the number of modular multiplications and additions in the matrix–vector stage by $\otimes$9–$\oplus$0. The hardware pipeline arranges all operations in a feed-forward manner, with no intermediate buffering, yielding a $\oplus$1 reduction in execution time and $\oplus$2 improvement in throughput performance on FPGAs compared to prior two-parallel implementations (Tan et al., 2023).

Coherent Optical and Quantum Reductions

Coherent free-space optical MVMR leverages cascaded SLMs, 4f imaging, and the Fourier-transform property of cylindrical lenses to compute $\oplus$3 in parallel for up to $\oplus$4 at high throughput and low energy, with systematic pixel-by-pixel calibration. This architecture supports real-valued dense operations and is pertinent for optical neural networks and Ising machine acceleration (Spall et al., 2020).

Quantum algorithms for MVM attain worst-case to average-case reductions with quadratic overhead in the average-case success probability $\oplus$5 (i.e., $\oplus$6), significantly improving upon previous quasi-polynomial constructions. The reduction exploits self-amplification/direct-product techniques without reliance on heavy analytic combinatorics, and rigorously composes block-wise reductions and verification circuits (Aggarwal et al., 17 Oct 2025).

4. Communication, Reduction, and Scalability Strategies

MVMR faces bottlenecks in I/O, communication, and data movement beyond computational arithmetic:

• PMV (pre-partitioned generalized matrix-vector multiplication) partitions $\oplus$7 once into $\oplus$8 blocks, then selects at each iteration among horizontal, vertical, or hybrid placement to trade off between broadcasting $\oplus$9 vs. shuffling partial results $y$0, with cost models capturing the impact of density, degree-thresholding, and placement strategies (Park et al., 2017).
• I/O-optimal strategies reduce shuffling and synchronization, favoring in-memory or network-bandwidth-limited systems in web- and graph-scale mining.
• Column reordering via similarity-score-driven heuristics (e.g., PathCover, Lin–Kernighan) can drive 16% further memory reduction and up to 25% speedup for compressed MVMR (Ferragina et al., 2022).

In distributed settings, “overlapped” vector representations enable pressure-free balancing, with sum-reductions (e.g., MPI_Allreduce) only over the reduced dimension, and with judicious partitioning the dominant communication cost stays $y$1 or less (Eckstein et al., 2018).

5. Theoretical Barriers, Open Questions, and Impact

• The OMV conjecture, long believed to undergird hardness for dynamic/query problems, can be shattered in the randomized and cell-probe models but remains an open landscape for deterministic and more general semiring cases (Larsen et al., 2016).
• Structure (manifest in VC-dimension or entropic compressibility) is a principal enabler of subquadratic algorithms, reconciling the dichotomy observed between theoretical lower bounds and practical performance (Anand et al., 28 Feb 2025).
• Black-box kernel MVMR has enabled scalable principal component analysis and Gaussian process inference for geostatistics, with $y$2 scaling; practical implementations achieve 19$y$3 parallel speedup on commodity multicore platforms (Wang et al., 2019).

Extensions to quantum fine-grained reduction frameworks, high-throughput analog/optical solutions, and application-tuned hardware demonstrate the cross-cutting centrality and evolution of MVMR as both a conceptual and technological primitive.

6. Comparative Hardware and Algorithmic Complexity Overview

Approach/Domain	Key Feature	Core Complexity/Scaling
Classical OMV	Online, Boolean, worst-case barrier	$y$4 (Larsen et al., 2016)
VC-dim-structured	Preprocessing + subquadratic query	$y$5 + $y$6 (Anand et al., 28 Feb 2025)
In-memory DA ReRAM	Multiplier-free, LUTs	$y$7 latency, $y$8 energy over bit-slice (Zeller et al., 2 Oct 2025)
Hardware/compressed (FPGA)	$y$9 multipliers/adders	$(S, \otimes, \oplus)$0 multipliers (Cariow et al., 2014)
Kernel black-box	Hierarchical $(S, \otimes, \oplus)$1	$(S, \otimes, \oplus)$2 (Wang et al., 2019)
PMV graph-mining	Pre-partition, hybrid comm.	Network I/O $(S, \otimes, \oplus)$3 per iter (Park et al., 2017)
Optical Engine	SLM + Fourier	$(S, \otimes, \oplus)$4, $(S, \otimes, \oplus)$5 ops/J (Spall et al., 2020)
Quantum reduction	Worst-case↔avg-case	$(S, \otimes, \oplus)$6 (Aggarwal et al., 17 Oct 2025)
Grammar-compressed	Time/space ∼ $(S, \otimes, \oplus)$7	Direct $(S, \otimes, \oplus)$8, memory/proportional to entropy (Ferragina et al., 2022)

7. Applications and Future Directions

MVMR methods are foundational for dynamic graph algorithms (dynamic Laplacian solvers, effective resistance, triangle detection—now admitting subquadratic time for structured inputs (Anand et al., 28 Feb 2025)), scalable learning (kernel PCA, deep neural inference (Zeller et al., 2 Oct 2025, Spall et al., 2020)), cryptography (lattice-based PQC engines (Tan et al., 2023)), and numerical computing on sparse and dense regimes.

Future directions include: tightening bounds for structured but adversarially perturbed inputs; extending efficient in-memory, optical, and quantum MVMR to more general operator classes; and further integrating communication and I/O models into core algorithmic design. The interplay of algebraic, architectural, and information-theoretic insights will likely continue to advance the state of the art in matrix-vector multiplication and reduction.