VVE EigenCore

The deterministic eigensolver.

Forty-nine minutes becomes twenty-nine seconds. Same code, same call, and the same answer on Intel, AMD and Arm.

You switch it on when you start your program. Nothing in your code changes.

VVE EigenCore is one 1.4 MB file that sits under the math calls your program already makes. The clock: one problem with 16,384 unknowns, solved start to finish by single-threaded reference netlib LAPACK and by VVE, one processor core each, on the same machine.

One input. Four builds. One answer.

One problem with 4,096 unknowns, solved on four different builds. The fingerprint of each answer, compared.

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

In plain terms

What VVE does, in plain words.

VVE finds the eigenvalues of a symmetric matrix: the handful of numbers that describe how a structure vibrates, where a signal came from, or which energy levels a system allows. It returns the same result on every machine, and it is fastest when the matrix has structure. The three terms below explain each of those claims before the numbers make them.

EigensolverWhat is it?
a matrix: many numbersits few values
A matrix of many numbers goes in. A handful of values that describe it comes out.

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?

A tuned math library, two chips

  • chip A0.70710678118654752
  • chip B0.70710678118654746

the last digits moved

VVE EigenCore, the same two chips

  • chip A0.70710678118654752
  • chip B0.70710678118654752

identical, every bit


Illustrative digits. The measured fingerprints are on the determinism page.

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?
densebanded
Dense: every entry holds a number. Banded: the numbers sit on a narrow band and the rest is zero. VVE SmartRoute works along the band.

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.

Different chips, different compilers

x86Intel · AMDArmArmsame answer, bit for bit
An Intel or AMD server and an Arm board return the same answer, bit for bit. Two different compilers too. 96 recorded answers compared, zero mismatches.

VVE carries its own arithmetic, so there is no vendor math library underneath to behave differently on a different chip.

What bit-identical means here →

Small enough to ship anywhere.

libvve.so, to scale

1.4 MBVVE7–60 MBtuned LAPACK + BLAS
One 1.4 MB file against 7–60 MB for a tuned vendor math stack. It needs nothing beyond what Linux already ships.

A problem with 524,288 unknowns: VVE peaks at 53 MB where holding the whole matrix would take 2,048 GiB.

The memory law →
The standard route works through every entry of the matrix, so doubling the problem costs eight times the work. VVE SmartRoute finds the band that holds the answer and works along it, so doubling the problem costs four times. Same matrix, same answer.

Fit check

Where VVE fits.

VVE is built for problems where each point only interacts with its neighbours. That shows up in the matrix as a narrow band, and the band is where VVE is fast.

  • Radar, sonar and 5G arrays

    angleantenna arraysignal
    Which direction did the signal come from? The answer is an eigenproblem solved on every frame, on a board with no room to spare.banded covariance
  • Bridges, machines and buildings

    masses and springshow it shakes
    How will this structure shake? Each point pulls only on its neighbours, so the matrix is a narrow band from end to end.tridiagonal, second-difference
  • Molecules and materials

    energy levelscrowded
    Which energy levels can an electron sit at? The levels crowd close together near the top, which is the hard case for a solver.Schrödinger, Wilkinson-type spectra

Not a fit. Dense matrices with no structure. Tuned vendor libraries already do that well, and VVE does not compete there.

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.

A radar, a sonar or a phone mast has to work out where a signal came from. Here is the whole story in four pictures.

  1. A signal arrives.

    angleantenna arraysignal
    A row of antennas, or microphones, all hear the same signal.
  2. Each one hears it a moment apart.

    a moment later
    The signal reaches the far end of the row a fraction later than the near end.
  3. The math turns those moments into one direction.

    the answerleftdirectionright
    An eigensolver takes a table of all those differences apart. Out comes a sharp peak at the direction the signal came from.
  4. Every frame, on a small board, the same answer.

    a small boardthe same answer, every frame
    Ready before the next frame, on a board with no room to spare, the same on every board so it is signed off once.

That third step is an eigenproblem solved under a clock, and it is the one workload that needs all three VVE outcomes at once: fast on this kind of matrix, identical on every board, and 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

A drop-in for existing LAPACK calls, a direct call for banded data, 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.