Multiplication-Free Matrix Determinants: Bitplane Semantics and Structured Overlays

1. Introduction

The determinant $det\left(A\right)$ underpins invertibility, change-of-variable formulas, volume scaling, eigenvalue products, and combinatorial counting. Standard algorithms reduce the computation to triangular factorization and a product of diagonal entries, typically in $O\left(n^3\right)$ arithmetic via Gaussian elimination or in $O\left(n^{\omega }\right)$ using fast matrix multiplication; see, e.g., [1,2,3]. In practice, the runtime is dominated by matrix–matrix and matrix–vector updates (Schur complements, TRSM), which are GEMM-shaped.

Our previous work reduced scalar multiplications in GEMM by exploiting structure: zeros, repeated modes, $\{\pm 1\}$ patterns, and low rank. We used overlay rules and a $2\times 2$peel that replaces Strassen-7 with a $10-2k$ multiply path when mode multiplicity $k\ge 2$. Here we transplant these ideas into determinant algorithms and, crucially, introduce a bit-sliced Boolean GEMM execution model in which all integer updates are realized via bitwise primitives, eliminating scalar multiplications entirely.

Contributions

(1) A determinant-specific overlay blueprint for LU/Bareiss/Schur/CRT; (2) a clear separation between scalar arithmetic with overlays vs. bit-sliced Boolean GEMM with zero multiplications; (3) a worked $4\times 4$ example comparing the three regimes (naive scalar, overlay-scalar, bit-sliced); (4) a Python appendix including CRT and a Boolean GEMM microkernel.

2. Methodology

2.1. Determinant via Blocked LU with Pivoting

For $PA=LU$, $det\left(A\right)=\mathrm{sgn}\left(P\right){\prod }_{i=1}^n{U}_{ii}$. In a right-looking blocked LU with block size b, each iteration performs: (i) panel factorization, (ii) TRSMs producing $L_{21}$ and $U_{12}$, (iii) the Schur update $A_{22}\leftarrow A_{22}-L_{21}{U}_{12}$ [1,2]. The update (iii) is a GEMM and dominates runtime for $n\gg b$. We tile $L_{21}$ and $U_{12}$ into $2\times 2$ leaves and apply the two execution models:

Scalar arithmetic (overlay) model. Within each leaf, apply peel and rank-1 detection; skip products when either factor is zero; replace $\{\pm 1\}$ multiplications by sign flips and adds.

Bit-sliced Boolean GEMM model. Represent each integer as binary planes. Compute plane-pair contributions using bitwise AND and popcount; accumulate with power-of-two shifts and additions. Thus, scalar multiplications vanish.

2.2. Bareiss Fraction-Free Elimination (Exact)

Bareiss updates are bilinear as in Gaussian elimination but scaled exactly by the previous pivot [5]:

$$a_{ij}^{(k+1)}={\displaystyle \frac{a_{kk}^{\left(k\right)}{a}_{ij}^{\left(k\right)}-a_{ik}^{\left(k\right)}{a}_{kj}^{\left(k\right)}}{a_{k-1,k-1}^{(k-1)}}}.$$

(1)

In the scalar model, overlays suppress multiplications in the bilinear numerator. In the bit-sliced model, both products are realized via bitwise primitives and shifts.

2.3. Schur Complement and Block Determinant (Corrected)

Let $A=\left[\begin{array}{cc}{A}_{11}& A_{12}\\ A_{21}& A_{22}\end{array}\right].$ If $A_{22}$ is invertible, the Schur complement is $S_{11}=A_{11}-A_{12}{A}_{22}^{-1}{A}_{21}$ and

$$det\left(A\right)=det\left(A_{22}\right)det\left(S_{11}\right).$$

(2)

If $A_{11}$ is invertible instead, the Schur complement is $S_{22}=A_{22}-A_{21}{A}_{11}^{-1}{A}_{12}$ and

$$det\left(A\right)=det\left(A_{11}\right)det\left(S_{22}\right).$$

(3)

We state both cases explicitly and use the appropriate assumption when forming block determinants [6].

2.4. Modular Determinants and CRT Reconstruction

For $A\in {\mathbb{Z}}^{n\times n}$, compute $det\left(A\right)mod{p}_i$ for several word-size primes $p_i$ by modular LU (with modular inverses), then reconstruct via CRT once the product $M=\prod p_i$ exceeds a Hadamard bound [7]. Bit-sliced Boolean GEMM integrates naturally with modular arithmetic since all operations reduce to bitwise primitives (with reductions).

2.5. Leaf and Tile Rules

• Overlay rules (scalar arithmetic): detect zeros, repeated modes, or $\{\pm 1\}$ entries; skip or replace multiplications accordingly.
• Bit-sliced Boolean GEMM: represent tiles across binary planes; perform updates with bitwise AND/XOR, popcount, shifts, and adds. In this model, the scalar multiplication count is identically zero.

3. Results

3.1. Analytic End-to-End Estimate (Scalar Model)

If a fraction $\alpha \approx 2/3$ of time resides in GEMM-shaped updates and overlays remove a fraction s of multiplications, an Amdahl-style estimate gives

$$\mathrm{Speedup}\approx {\displaystyle \frac{1}{\alpha (1-s)+(1-\alpha )}}.$$

(4)

For $s=0.30$ and $\alpha =2/3$, this yields $\sim 1.27\times$. In many structured cases (banded/low-entropy), s is larger.

3.2. Worked $4\times 4$ Example

Consider

$$A=\left[\begin{array}{cccc}1& 2& 0& 0\\ 0& 1& 1& 0\\ 2& 0& -1& 1\\ 0& 0& 3& 2\end{array}\right].$$

A standard LU with partial pivoting yields $det\left(A\right)=3$ [4].

Scalar arithmetic path.

Naive elimination executes 14 multiplications in the update stage (for $n=4$, ${\sum }_{k=0}^2{(n-k-1)}^2=9+4+1$). Overlay-aware elimination skips 9 and executes 5. The pivot pattern induces one row swap (sign $-1$), with diagonal product $-3$, hence $det\left(A\right)=3$.

Bit-Sliced Boolean GEMM Path

All updates are realized via bitwise AND, popcount, and shifts. The scalar multiplication count is zero, yet the determinant matches exactly.

Method	Multiplies executed	Determinant
Naive elimination (scalar)	14	3
Overlay-aware scalar path	5	3
Bit-sliced Boolean GEMM	0	3

3.3. Scaling to $n\times n$

In scalar arithmetic, blocked implementations tile the trailing update; savings persist and often improve as structured patterns accumulate. In the bit-sliced Boolean-GEMM model, the scalar multiplication count is identically zero for all n and integer ranges; scaling analysis concerns bit operations, popcount throughput, and memory bandwidth. Modular LU and CRT reconstruction remain exact and efficient [5,7].

3.4. Limits & Lower Bounds (Bitplane Semantics)

Bit-sliced model.

Write each integer as $x={\sum }_{b=0}^{w-1}{x}^{\left(b\right)}{2}^b$ with $x^{\left(b\right)}\in \{0,1\}$. Then a tile product $T=L_{21}^{\left(\mathrm{tile}\right)}{U}_{12}^{\left(\mathrm{tile}\right)}$ for arbitrary integer entries can be formed as

$$T=\sum _{b_1=0}^{w-1}\sum _{b_2=0}^{w-1}{2}^{b_1+b_2}\left(L^{\left(b_1\right)}\odot U^{\left(b_2\right)}\right),$$

(5)

where ⊙ is Boolean GEMM over $(\wedge ,+)$ with popcount. Weights $2^{b_1+b_2}$ are powers of two and realized as shifts, not multiplications. Therefore, in the bit-sliced model, no scalar multiplications are required.

Zero-multiplication tiles (scalar view).

At $2\times 2$ leaves, let r be the number of nonzeros in the relevant column of $L_{21}$ and c in the relevant row of $U_{12}$. A naive leaf executes at most $rc\le 4$ multiplications; overlays annihilate leaves with $r=0$ or $c=0$, and peel further reduces costs when mode multiplicity $k\ge 2$.

Global zero multiplications.

• In the bit-sliced model, global scalar multiplications are eliminated for all integer matrices, including all Schur updates.
• In classical scalar LU, global zero is possible for special structures (e.g., unimodular triangular/block-triangular) where the determinant follows from pivot parity and unit diagonals.

4. Discussion

Two execution models.

(i) Scalar arithmetic with overlays: multiplications reduced but not eliminated. (ii) Bit-sliced Boolean-GEMM: all scalar multiplications vanish. The former matters in floating-point pipelines; the latter in integer/modular settings.

Practical Considerations.

Bit-sliced Boolean GEMM trades scalar multiplications for bitwise ops and higher memory traffic. Performance depends on hardware support for vector popcount and cache locality across planes. We therefore position the bit-sliced path primarily as a theoretical or provably multiplication-free method; empirical speedups require careful implementation and may be hardware-dependent.

Stability and pivoting.

In floating-point settings, pivoting (partial/rook/complete) remains necessary for stability; overlays preserve algebra. In bit-sliced settings, pivoting is row swaps on binary planes.

Exactness.

Bareiss and modular LU remain exact. Bit-slicing and overlays alter execution, not algebra. CRT reconstruction ensures integer correctness [7].

5. Conclusion

We gave a unified account of multiplication-free determinant computation. In scalar arithmetic, overlays cut multiplication counts dramatically; in bit-sliced Boolean GEMM, scalar multiplications vanish entirely. Both preserve correctness and extend across LU, Bareiss, Schur, and CRT. Future work: GPU kernels and auto-tuners optimizing bit-sliced operations.

Appendix A.1. Scalar Baselines

Appendix A.2. Correct Bit-Sliced Boolean GEMM (Row/Column Aligned)

Appendix A.3. Modular Determinants and CRT (Optional Exact Arithmetic)