Valori: A Deterministic Fixed-Point Vector Kernel

Tags:
vector-database, rust, determinism, finance, audit, hnsw, fixed-point, systems-engineering

TL;DR

Floating-point math causes vector search results to drift between ARM (Mac) and x86 (Linux) architectures due to compiler and hardware variances. Valori is a Q16.16 Fixed-Point kernel written in Rust that guarantees bit-exact reproducibility across all hardware platforms, making it the first "Audit-Grade" vector engine for high-stakes AI.

1. The Problem: "The Silent Drift"

Most vector databases (FAISS, Pinecone, Weaviate) rely on hardware-accelerated floating-point arithmetic (f32). While fast, this introduces Non-Determinism:

• Associativity Variance: (a + b) + c ≠ a + (b + c) depending on SIMD optimizations.
• Architecture Variance: A backtest run on a MacBook (ARM NEON) often yields different nearest neighbors than the live execution on an AWS Server (Intel AVX2).

In RAG pipelines, this is annoying. In High-Frequency Trading or Legal Forensics, this variance is a liability. You cannot audit a probabilistic black box.

2. The Solution: Valori Kernel

Valori is a forensic memory engine built from scratch in Rust. It replaces standard floating-point math with a custom Q16.16 Fixed-Point Arithmetic system inside an HNSW graph.

• Zero Drift: The mathematical operations are integer-based. 1 + 1 = 2 on every CPU, forever.
• Audit-Ready: Includes a calculate_state_hash() method that generates a cryptographic fingerprint of the database state. If a single bit changes, the hash breaks.
• Crash Proof: Implements a specialized persistence layer with <40ms recovery time (Cold Boot to Full Query) for 50k vector datasets.

3. Benchmarks (Engineering Verification)

Validated on Apple M2 (ARM64) vs Intel Xeon (x86_64).

4. Usage (Rust)

Valori is designed to be embedded directly into high-integrity Rust applications.

Add to Cargo.toml:

[dependencies]
valori_kernel = { git = "https://github.com/varshith-Git/Valori-Kernel" }

Example: Deterministic Ingest & Audit

use valori_kernel::{ValoriKernel, types::FixedPointVector};

fn main() -> anyhow::Result<()> {
    // 1. Initialize the Kernel (Q16.16 Math)
    let mut kernel = ValoriKernel::new();

    // 2. Ingest Data (Manual f32 -> FixedPoint conversion for safety)
    let raw_vector = [0.5, -0.2, 0.9, ...]; // 128-dim
    
    // Convert float to Q16.16 integer representation
    let mut fixed_arr = [0i32; 128];
    for (i, &val) in raw_vector.iter().enumerate() {
        fixed_arr[i] = (val * 65536.0) as i32;
    }
    
    // Insert with ID=1, Tag=100
    kernel.insert(1, FixedPointVector(fixed_arr), 100);

    // 3. Search
    // Guaranteed to return the exact same ID and Distance on any CPU
    let results = kernel.search(&fixed_arr, 5, None)?;
    println!("Found neighbors: {:?}", results);

    // 4. Generate Forensic Evidence
    // This hash proves the database state is identical bit-for-bit
    let audit_hash = kernel.graph.calculate_state_hash();
    println!("Cryptographic State Signature: {}", audit_hash);
    
    Ok(())
}

5. Who is this for?

• Quant Developers: Who need backtests to match live execution perfectly.
• Systems Engineers: Debugging "Why did the agent say X?" (Eliminate the database as a variable).
• Auditors: Who need to certify AI decision logs using cryptographic proofs.

Citation

If you use Valori in your research, please cite:

@misc
	{gudur2025valori,
  title={Valori: A Deterministic Fixed-Point Vector Kernel},
  author={Gudur, Varshith},
  year={2025},
  publisher={arXiv},
  url={https://arxiv.org/abs/2512.22280}
}