Matrices

A matrix is a grid of numbers, arranged in rows and columns. That’s all.

Matrices matter to Pearl because they matter to AI. A language model stores what it has learned as huge matrices of numbers, and running it means multiplying matrices, billions of times. Pearl’s mining is exactly that multiplication. This group of pages explains the math behind it, starting with the grids themselves.

What does a matrix look like?

Here is a small one: the toy matrix A from Pearl’s worked mining example. It has 4 rows and 16 columns, filled with whole numbers from −4 to 4. Darker cells hold bigger numbers, positive or negative.

Its shape is 4 × 16: rows first, then columns. It has 4 × 16 = 64 entries. The entry in row i and column j is written A_ij, so A_0,2 = 4. (Programmers count from 0.)

A matrix with one row or one column is called a vector. A matrix with as many rows as columns is square. Pearl’s are usually rectangular.

What are Pearl’s matrices A and B?

A Pearl miner multiplies two matrices of its own choosing:

In Pearl’s official miner, the multiplication is a layer of a language model running inside the vLLM serving software:

• A holds the model’s activations: one row per token (a word piece), one column per feature. Mining only kicks in when a batch has at least 1,024 tokens.
• B holds the layer’s weights: k inputs by n outputs.
• C = A·B is the layer’s output, which the model needs anyway.

In practice the GPU kernel keeps the weights as an n × k grid and computes A times its transpose. The transpose Bᵀ is B flipped over its diagonal, rows becoming columns. That turns out to be exactly the layout Pearl fingerprints, as you’ll see below.

Where are A and B inside a language model?

In the official miner’s mining mode, any large linear layer can mine: the attention projections (query, key, value and output) and the feed-forward projections (gate, up and down). Each multiplies a batch’s activations by a weight matrix.

Only big multiplications mine: at least 1,024 tokens, n of at least 256 and k of at least 1,024. Smaller ones run as a plain multiplication. That suggests, though Pearl doesn’t say so, that mining happens mostly while a model reads long prompts or large batches, not while it writes one token at a time. Pearl Research Labs publish versions of Llama 3.3 70B and Llama 3.1 8B prepared for the miner.

What rules do the matrices have to follow?

The certificate declares the sizes, and every node checks them:

The entries’ range is narrow on purpose: the integers page explains why. The link between k and r comes from the noise.

How is a matrix stored as bytes?

A computer’s memory is one long line of bytes, so a grid has to be flattened. There are two natural ways:

• Row-major: row 0 left to right, then row 1, and so on.
• Column-major: column 0 top to bottom, then column 1, and so on.

Each entry is one signed byte (−3 is fd, see bytes). So the first row of the toy A, −3, 1, 4, 4, …, becomes the bytes fd 01 04 04 ….

How does Pearl fingerprint a matrix?

Before mining, the miner commits to both matrices. It takes the bytes of A row by row, and of B column by column, pads each with zero bytes to a multiple of 1,024, and hashes them with keyed BLAKE3, using the job key:

BLAKE3 is a Merkle tree over 1 KiB chunks, so this fingerprint is a Merkle root. Later, the miner can prove that the two rows and few columns of its winning tile belong to the committed matrices, with short paths of sibling hashes.

That’s why B is stored by columns. A tile needs whole columns of B, and column-major storage makes each column a contiguous run of chunks.

Block 130,825’s certificate carries both fingerprints (raw bytes, as stored):

These fingerprints feed the noise seeds: change one entry of A and all of A’s noise changes; change one entry of B and the noise of both matrices changes, because B’s seed feeds into A’s.

import { blake3 } from '@noble/hashes/blake3.js';

const rowMajor = (M) => Int8Array.from(M.flat());                 // A, row by row
const colMajor = (M) => Int8Array.from(M[0].flatMap((_, j) => M.map((row) => row[j]))); // B, column by column
const pad1024 = (b) => { const out = new Uint8Array(Math.ceil(b.length / 1024) * 1024); out.set(new Uint8Array(b.buffer)); return out; };

const hashA = blake3(pad1024(rowMajor(A)), { key: jobKey });
const hashB = blake3(pad1024(colMajor(B)), { key: jobKey });