Verifiable Computation
You computed something expensive. The consumer needs to know the result is correct.
Prove it without re-executing. Verify at 31 nanoseconds.
Verifiable computation is the ability to prove that a computation was performed correctly without requiring the verifier to re-execute it. The prover attaches a computation fingerprint — SHA3-256(input || computation || parameters || version || hardware) — to the result. The result is signed by three independent post-quantum signature families. The verifier checks the fingerprint and signatures. If they match, the result is correct. No re-execution. No trust assumption. 31 nanoseconds.
How Do You Know the Result Is Correct?
You receive a computation result from another system. An ML inference score. A risk calculation. A compliance check. A financial aggregation. How do you know the result is correct?
Today, you have three options. All of them are inadequate.
Three Ways to Verify. Only One Scales.
Re-computation doubles your cost. Trusted third parties add a trust assumption. Cachee's computation fingerprint proves correctness at 31 nanoseconds with zero re-execution and zero trust in the prover.
The Computation Fingerprint
A computation fingerprint is a deterministic hash that uniquely identifies a computation result by binding it to everything that produced it. It is a content address — the address IS the proof.
fingerprint = SHA3-256(
input_data // the exact input bytes
|| computation_type // "ml_inference", "risk_calc", etc.
|| parameters // model version, thresholds, config
|| software_version // exact binary hash
|| hardware_id // platform identifier
)
// The fingerprint is deterministic:
// Same inputs + same computation = same fingerprint. Always.
// Different input (even 1 bit) = completely different fingerprint.
Two independent systems running the same computation on the same inputs will produce the same fingerprint. This is the basis of verifiability. You do not need to trust the prover. You verify the fingerprint. These results don't live in isolation — they become a tamper-proof audit trail.
The Verification Flow
From computation to verified result in five steps.
Signed Results: Three PQ Families
A fingerprint proves what was computed. Signatures prove who computed it and that it has not been modified. Every cached result is signed by three independent post-quantum signature families:
| Family | Algorithm | Basis | Signature Size | NIST Level |
|---|---|---|---|---|
| Lattice (MLWE) | ML-DSA-65 | Module lattices | 3,309 bytes | Level 3 |
| Lattice (NTRU) | FALCON-512 | NTRU lattices | 656 bytes | Level 1 |
| Hash-based | SLH-DSA | Stateless hashes | 17,088 bytes | Level 1 |
Forging a result requires breaking MLWE lattices, NTRU lattices, AND stateless hash functions simultaneously — three independent mathematical assumptions. This is not defense in depth. It is mathematical redundancy. This is the foundation of verifiable audit infrastructure.
Cachee Fingerprints vs ZK Proofs
Both prove computation correctness. They serve different purposes.
Zero-Knowledge Proofs
Proves a statement without revealing data. Requires circuit compilation, trusted setup (SNARKs), or FRI protocol (STARKs). Verification: 1ms-25us. Proof generation: seconds to minutes. Use when you need input privacy.
Cachee Computation Fingerprint
Proves a computation was executed correctly on specific inputs. No circuit compilation. No trusted setup. SHA3-256 hash + PQ signatures. Verification: 31ns from cache. Use when you need proof of correct execution, not input privacy.
| Property | ZK Proofs | Cachee Fingerprints |
|---|---|---|
| Input Privacy | Yes (hidden) | No (inputs bound) |
| Proof Generation | Seconds to minutes | 96ns (SHA3-256) |
| Verification | 1ms - 25us | 31ns from cache |
| Setup Required | Circuit compilation | None |
| Post-Quantum | Depends on scheme | Yes (3 PQ families) |
| Proof Size | 200B - 100KB | 32 bytes (fingerprint) |
If you need to prove "I know X without revealing X," use ZK proofs. If you need to prove "this result was correctly computed from these inputs," use Cachee. They are complementary — and Cachee can cache ZK verification results at 85ns.
Independent Verification
The verification is independent. You do not need a Cachee account, a network connection, or trust in H33 to verify a computation result. The cachee-verify tool is a standalone binary that checks:
- Fingerprint match: Recompute
SHA3-256(input || computation || params || version)and compare to the claimed fingerprint - ML-DSA-65 signature: Valid lattice-based signature over the fingerprint
- FALCON-512 signature: Valid NTRU-based signature over the fingerprint
- SLH-DSA signature: Valid hash-based signature over the fingerprint
All four checks must pass. If any one fails, the result is rejected. The verification is offline, deterministic, and takes 31 nanoseconds from cache.
Run it yourself: brew install cachee && cachee verify-demo
Re-Computation vs Cached Verification
A typical ML inference takes 10ms. Verifying via re-computation takes another 10ms. Verifying via Cachee takes 31 nanoseconds.
Where Verifiable Computation Matters
Get Started
brew tap h33ai-postquantum/tap && brew install cachee
cachee init && cachee start
# Store a computation result with fingerprint
SET result:calc_789 '{"value":42.7}' FP compute=aggregation input=dataset_A ver=1.3.0
# Verify the result (offline, no network)
cachee-verify result:calc_789
# Retrieve verified result at 31ns
GETVERIFIED result:calc_789
Every SET is automatically fingerprinted and PQ-signed. The FP flag adds the computation fingerprint binding. GETVERIFIED returns the result only if signatures are valid. Zero additional infrastructure. Every output is tied to its origin through data lineage verification.
Deep Dives
Explore Verifiable Computation Infrastructure
Every page in the Cachee knowledge base. Proven computation, not cached data.
The category definition. Run computation once, serve forever. →Computation Fingerprinting
Identity for results. Provenance, not just output. →Cache Attestation
Signed cache entries. Three PQ families per SET. →ZK Caching
Cache STARK and SNARK verification results at 85ns. →Tamper-Proof Audit Trails
SHA3-256 hash-chained immutable logging. →Compliance-Ready Infrastructure
Pass audits without slowing down.