rolvai/rolv-benchmark

ROLV Benchmark

Sparse operator verification and performance benchmark suite for ROLV Primitive©.

Published by Rolv Eitrem Heggenhougen · rolv.ai · 3 Patents Pending

---

The idea in one sentence

You supply numbers only you know. You compute the expected answer yourself. ROLV gets the same answer — proving it performs real computation, not fabricated results.

---

What is this?

A deterministic sparse matrix benchmark with three purposes:

1. Zero-trust verification — prove ROLV correctness with your own secret inputs
2. Performance benchmark — measure ROLV speedup vs dense and CSR across sparsity levels
3. Education — understand exactly what row sparsity means and why it matters

---

Install

pip install rolv-benchmark

Or from source:

git clone https://github.com/rolvai/rolv-benchmark
cd rolv-benchmark
pip install -e .

---

Quick start

Verify with your own secret numbers

from rolv_benchmark import verify
import numpy as np

# Use numbers only YOU know — ROLV must get the same answer
my_numbers = np.array([7, 13, 42, 99, 3, 17, 8, 100] * 16, dtype=np.float32)

result = verify(x=my_numbers)
# Prints a verification report including rows you can check by hand

From the command line:

python -m rolv_benchmark verify --x 7 13 42 99 3 17 8 100

The verification logic:

1. A deterministic weight matrix W is generated from a published seed — same on every machine
2. Your input x is multiplied: y = W @ x
3. 80% of output rows are exactly zero (ROLV skips them)
4. 20% are active — you can verify each with a calculator: sum(W[i] * x)
5. ROLV and dense give identical results to 1e-5 tolerance
6. Publish your SHA-256 hashes to let anyone reproduce your specific run

Run the performance benchmark

python -m rolv_benchmark benchmark

Output:

  ROLV BENCHMARK  10000×128  batch=512
  Sparsity    Dense ms   ROLV ms   Speedup           Err   PASS
  ─────────────────────────────────────────────────────────────
        0%      1.8230    1.8441     0.99×   0.00e+00      ✓
       50%      1.8230    0.9412     1.94×   0.00e+00      ✓
       70%      1.8230    0.5312     3.43×   0.00e+00      ✓
       80%      1.8230    0.3821     4.77×   0.00e+00      ✓
       90%      1.8230    0.2104     8.66×   0.00e+00      ✓
       95%      1.8230    0.1203    15.15×   0.00e+00      ✓
       99%      1.8230    0.0489    37.28×   0.00e+00      ✓

Show matrix parameters

python -m rolv_benchmark info

---

The matrix structure

W: shape (10 000, 128)
├── 8 000 rows: exactly zero  ← ROLV skips all of these
└── 2 000 rows: non-zero      ← ROLV computes only these

Row sparsity: 80%
ROLV compression: 5×

ROLV's CRCS™ algorithm identifies zero rows and skips them entirely — no multiply, no memory access, no energy. The speedup grows with row sparsity: at 99% only 100 rows are active out of 10 000, giving ~37× speedup on CPU.

The weight coefficients are rounded to 4 decimal places so any active row can be verified with a pocket calculator:

W[423] = [0.1234, -0.5678, 0.9012, ...]
x      = [7,       13,      42, ...]
dot    = 0.1234×7 + (-0.5678)×13 + 0.9012×42 + ... = ?

---

Why this is a stronger proof than hashes alone

Standard benchmark hashes (SHA-256 of W, x, output) prove the computation was run on specific data — but someone could pre-compute results and fake the timing. This benchmark adds a second layer:

You supply x — numbers only you know.

If ROLV returns the value you computed on your calculator, using your numbers, it cannot have pre-computed that result. The proof is zero-trust by construction.

To publish your verification:

1. Run python -m rolv_benchmark verify --x <your_numbers>
2. Publish the printed hash_W and hash_x
3. Anyone can reproduce by running with the same x

---

Scaling

ROLV advantage grows with:

Dimension	Why
Sparsity ↑	More rows skipped → larger compression
Matrix size ↑	More absolute rows skipped at same sparsity %
Batch size ↑	Fixed overhead amortised across more columns

On GPU (not in this package — see rolv.ai):

• 80% sparsity → 10–12× speedup on NVIDIA B200
• 95% sparsity → 15–19× speedup on real LLM weights
• 550/550 PASS across 6 hardware platforms

---

The math

For each active row i:

$$y_i=\sum _{j=0}^{K-1}{W}_{ij}\cdot x_{j}y\_i\; =\; \backslash sum\_\{j=0\}^\{K-1\}\; W\_\{ij\}\; \backslash cdot\; x\_j$$

For zero rows: $y_i = 0$ (by construction, not approximation).

ROLV CRCS™ computes this as:

$$y[\text{active}]=W[\text{active rows},\text{active cols}]\cdot x[\text{active cols}]y[\backslash text\{active\}]\; =\; W[\backslash text\{active\; rows\},\; \backslash text\{active\; cols\}]\; \backslash cdot\; x[\backslash text\{active\; cols\}]$$

This is exact arithmetic — no approximation is introduced by ROLV itself. The only source of output difference from a dense model is pruning (zeroing rows), which is a user choice, not a ROLV artifact.

---

GPU acceleration

This package runs on CPU only for maximum portability and verifiability. The full GPU operator (NVIDIA, AMD, Intel) is available at rolv.ai.

GPU results: up to 83× speedup vs rocSPARSE on AMD MI300X, 13.64× vs cuSPARSE on NVIDIA H200, verified on exact LLaMA-3.1-70B dimensions.

---

Citation

@software{rolv_benchmark_2026,
  author  = {Heggenhougen, Rolv Eitrem},
  title   = {ROLV Benchmark: Sparse Operator Verification Suite},
  year    = {2026},
  url     = {https://github.com/rolvai/rolv-benchmark},
  note    = {3 Patents Pending}
}

---

ROLV Primitive© · CRCS™ · RSMT™ · ROLVswitch™ · 3 Patents Pending
rolv.ai · rolv@rolv.ai