VVE EigenCore

The deterministic eigensolver.

Forty-nine minutes becomes twenty-nine seconds. Same code, same call, and the same bits on x86 and Arm.

LD_PRELOAD=libvve.so python3 your_script.py
# nothing else changes.

VVE EigenCore is one 1.4 MB library under the LAPACK calls you already make. The clock is one full decomposition, second_diff, N = 16,384: single-threaded reference netlib LAPACK dsyev against VVE, one core each, same machine.

Request an evaluation build See the evidence →

One input. Four builds. One answer.

second_diff, N = 4,096 — SHA-256 of the eigenpair, IEEE-754 tier.

Change the machine. Change the compiler. Change the architecture. The answer does not move.

In plain terms

What this is, and why it matters.

Three words carry the whole site. Here is what each one means before the numbers start.

EigensolverWhat is it?: Many engineering problems arrive as a large grid of numbers, a matrix. Hidden inside it are a handful of values that describe how the whole thing behaves: the pitches a structure rings at, the direction a radar echo came from, the energy levels of a quantum system. An eigensolver finds those values. Nearly every scientific library has one, and most of them call LAPACK to do it. VVE EigenCore replaces that LAPACK call.
DeterministicWhy does it matter?: Fast math libraries choose a different route through the arithmetic depending on the chip they land on. The answers agree to many digits but not the last ones, so the same program on two machines returns two slightly different results. Harmless in a quick experiment. A real problem when a result has to be reproduced, audited or certified. VVE takes one route everywhere, so the result is the same bits on every machine. With no large tuned library underneath, it is also small enough to ship anywhere.
StructuredWhere is it faster?: Many of the matrices that matter in these fields are mostly zeros, with the information packed along a narrow band. The standard route still works through every entry. VVE SmartRoute, the structure-aware part of EigenCore, detects the band and works along it, so the effort grows with the square of the problem size rather than the cube. That is where the speed comes from, and it is also why VVE does not compete on dense, unstructured matrices.

What you get

Three outcomes. One number each.

Faster, where structure exists.

One core against one core, N = 16,384

98–103×

vs single-threaded reference netlib LAPACK dsyev (the default dense path) — same size, same routine, same machine

In wall clock: 2,932.9 s becomes 28.8 s for one full decomposition.

The measured record →

The same bits, everywhere.

Cross-architecture, cross-compiler

x86_64 ≡ aarch64

and GCC ≡ Clang. 96 SHA-256 records across 12 matrix and size groups, zero mismatches.

There is no BLAS backend to swap, so there is nothing to dispatch differently on a different chip.

What bit-identical means here →

Small enough to ship anywhere.

libvve.so

1.4MB

against 7–60 MB for a platform-specific LAPACK + BLAS stack. Runtime dependencies: libc, libm, libpthread.

At N = 524,288 the bands-native path peaks at 53 MB where the dense buffer is 2,048 GiB.

The memory law →

The dense path reduces the whole N×N matrix with Householder reflections, so doubling N costs 8×. VVE SmartRoute detects the band that carries the spectrum and works along it, where doubling N costs 4×. Same matrix, same eigenvalues.

Fit check

Where VVE wins. Where it does not.

Best fit

Symmetric eigenproblems with structure: tridiagonal, banded, second-difference, Wilkinson-type spectra.
Results that have to be reproduced, reviewed or certified after the fact.
Edge, embedded or air-gapped targets where a tuned BLAS stack does not fit.

Not fit

Dense, unstructured matrices. Tuned BLAS already owns that, and VVE does not compete for it.
A one-off desktop result with no reproducibility requirement.
Routines outside dsyev, dsyevd, dsyevr, dgesdd, dgesvd, dstev without an integration plan.

How the numbers were made

Every number names its opponent.

Each figure ships with the four things that make it checkable on your own hardware.

Named opponents: Every ratio names the library, the routine and the thread count on both sides.
Accuracy-gated: A faster wrong answer does not count. Both sides pass the same residual gate.
Run twice: Every headline figure was re-run end to end on independent hardware.
Signed: Benchmark manifests and determinism records ship with minisign signatures.

Method, in full →

Flagship workload

Array signal processing.

MUSIC and ESPRIT put a symmetric eigendecomposition inside the latency budget, on hardware with no room for a tuned BLAS. It is the one workload that needs all three outcomes at once: fast on structured covariance, identical on every board, small enough to fit beside the firmware.

Direction of arrival, end to end →

Three ways in

Each path lands with a person.

Evaluate

A VVE EigenCore evaluation build and the harness we measured with, run on your matrices. The first number you see is one you measured yourself.

Request an evaluation →

License or integrate

Drop-in under LD_PRELOAD=libvve.so, the bands-native API, or an integration plan for routines outside the covered set.

Partner with us →

Invest

The technical record, the claims discipline and the roadmap, shared with investor relations for diligence.

Investor relations →

Bring us a matrix.

Tell us the spectra you actually run and the hardware you have to run them on. We send an evaluation build and the harness we measured with, so the first number you see is one you measured yourself.

Request an evaluation Partner with us