Linear Algebra

§ Sparse Multiplication

Multiply reads an approximate sparse product off the graph: every pair the walk scored for each left row, in traversal order, rather than only the nearest. It runs on an inner-product index alone, and its keys, products and row offsets land in an arena like Get’s rows.

products, err := index.On(executor).Multiply(usearch.RowsOf(left, dimensions), arena, &usearch.DenseMultiplyConfig{Wanted: 64})
for row := range products.Queries() {
	columns, scores, _ := products.Query(row)
	accumulate(row, columns, scores)
}

§ Late Interaction

Maxsim scores multi-row queries against multi-vector documents: every query row takes its best match within a key, and those maxima sum to that key’s score. A document is one key holding its token rows, which is what a ValuesPerKey above one exists for, and the wanted count is over documents rather than rows. It runs on an inner-product index alone, since a sum of maxima needs logits rather than distances. The keys land as Multiply’s pairs do, one DenseProducts run per query, largest score first, and a zero wanted count keeps every key a query scored.

options.Metric = usearch.DenseMetricInner
options.ValuesPerKey = 512

documents, err := index.On(executor).Maxsim(usearch.RowsOf(tokens, dimensions), tokensPerQuery, 10, arena, nil)
for query := range documents.Queries() {
	keys, scores, _ := documents.Query(query)
	rerank(query, keys, scores)
}

§ Attention

Attend is Flash Attention folded into the walk: every key it scores folds into each head’s running maximum, partition and weighted value sum, with no top-k cut, and the outputs land in an arena already divided by the partition. The index stores no values, so a ValueLookup names, for every scored key, its row of a Values matrix as wide as the keys and stored in the index’s own quantization. A key without a row, or values of another width or scalar type, refuses the call with StatusShapeMismatch, since a missing row is a wrong softmax rather than a smaller one. A VRAM walk resolves its rows through a device function, which no Go function can be, so Attend refuses a VRAM index with StatusDevice. With HeadCount: 8, row t * 8 + h of the queries is head h of token t, and the heads of one token share its walk.

lookup := usearch.ValueLookup{
	Values: usearch.RowsOf(valueCache, dimensions),
	Row:    func(key usearch.Key) (uint, bool) { row, ok := rowOf[key]; return row, ok },
}
carry := make([]usearch.DenseSoftmaxState, queriesCount)
attended, err := index.On(executor).Attend(usearch.RowsOf(queries, dimensions), lookup, arena,
	&usearch.DenseAttendConfig{HeadCount: 8, Carry: carry})
context, _ := usearch.DenseValues[float32](attended)

The attended rows take the queries’ scalar type unless the config’s OutputsScalar names another. A Carry of one DenseSoftmaxState per query row, lent rather than written into the arena, folds this branch into another over the same queries, such as a recent window kept out of the index.