Corbenic/taliesin-receipts

Taliesin — Verification Receipts

The cryptographic proof behind every public claim Corbenic AI makes about Taliesin, our lossless external-memory engine. Don't trust us — check the hashes. Every result here is a SHA-256 receipt or a structured NDJSON/JSON record produced by the actual tests.

The Taliesin engine itself is proprietary and is not in this repository. What is here is the evidence: the hashes and structured outputs that let you verify the claims without our software.

The one property everything rests on

A grafted result (Taliesin restoring a stored KV state) is byte-for-byte identical to a fresh full-context computation — SHA-256(grafted logits) == SHA-256(fresh-prefill logits) — under deterministic kernels:

GGML_DETERMINISTIC=1   CUBLAS_WORKSPACE_CONFIG=:4096:8

Not "statistically similar." Identical at the bit level.

How to verify (read this — it's honest about what you can reproduce)

• The property graft == a fresh prefill is what the receipts show, on our hardware, within each trial.
• Independently reproducible on ANY GPU: the determinism precondition — run a fresh prefill of the same prompt twice on the open model under the env above and confirm the logit SHA is identical. Byte equality of the graft then follows by construction whenever the kernel is deterministic (Taliesin restores exactly the KV the kernel would have produced). A small helper is included: verify_determinism.py (uses only the open Galahad model + Hugging Face Transformers — no Corbenic software).
• Matching our absolute published hashes (e.g. 41a2c8cd…) additionally requires the same GPU architecture + same build — fresh-prefill kernels round floating point differently per GPU generation (see Cross-machine / cross-architecture below). The property is universal; the exact hash is hardware-specific.

Receipt index

Folder	What it proves	Headline
gates_and_final_test/	Galahad gates: graft == prefill	gate2 5/5 SHA byte-equal · gateC KL=0 over 40 samples · gate3 real xxhash3 backend · gateC_chain_paris 31-graft chain byte-identical to one 1,377-token prefill · parity HF↔llama.cpp
heavy_cross_vendor/	same engine, 3 vendors	45/45 SHA byte-equal — Llama-3.1-8B (Meta) + Qwen2.5-7B (Alibaba) + Mistral-7B (Mistral) × CTX 1024/4096/16384, 5 trials each (RTX 4090)
taliesin_persistence/	engine survives a process death	20/20 — Process B (fresh, empty registry) runs publish_kv → on_prompt_received → graft_kv on a KV loaded from disk; grafted logits SHA-match a third fresh-prefill process. A no-op engine would mismatch.
persistence_across_process/	substrate precondition	15/15 byte-identical disk round-trip using only public llama.cpp APIs — confirms the byte-exact KV-restore holds at the library layer.
taliesin_perf/	speed + composition + lifecycle	speedup curve (below) · composition byte-exact (graft span A + decode span B == fresh prefill of A‖B) · lifecycle (publish/evict/republish) · cross-model isolation · 8-prefix stress · semaphore cap
taliesin_tamper_concurrency/	safety on failure + concurrency	tamper: header-flip + truncation rejected at load; mid-byte flip decodes a different SHA (never silent-equal) · concurrency: N=2/4/8 threads, exactly 1 graft succeeds, others typed -2, success SHA matches control
paper_grade/	aggregated table	machine-readable summary JSON

Speedup (NVIDIA A6000, deterministic, FlashAttention-enabled prefill baseline)

CTX	Llama-3.1-8B	Qwen2.5-7B
4,096	1.35× (crossover)	2.55×
16,384	4.36×	8.69×
32,768	8.88×	16.26×
65,536	21.60× (140.6 s → 6.51 s)	—

Speedup grows with context; below ≈4K tokens the graft has fixed overhead and is not faster than a fresh prefill. (taliesin_perf/big_scaling_*.ndjson, scaling_*.ndjson)

Cross-machine / cross-architecture (summarised; full state.bin receipts on request)

State files are large FP16 blobs and need the engine to interpret, so they are not bundled here. Results:

• Cross-machine, same arch (A6000 ↔ A6000): state saved on Machine A, loaded on Machine B (fresh process), decodes SHA-identical to B's own fresh prefill, both directions. Shared SHA across all four trials: 41a2c8cd7135a618ba0487fa8441f87b4344ce9d8c2f2ebdf612cc587cd336db.
• Cross-architecture (Ampere A6000 ↔ Ada 4090): the 4090 loading the A6000's state decodes the A6000's SHA (41a2c8cd…); the reverse decodes the 4090's SHA (1de524c3…). A fresh prefill differs per architecture (the GPUs round floating point differently — a hardware fact, not an engine fact). Scope: this proves lossless state migration + the single decode at the handoff is byte-identical. It does not claim a full generated sequence on the new GPU matches a hypothetical old-GPU generation — once the new GPU appends tokens it uses its own kernels. Newer generations (Hopper, Blackwell) and non-NVIDIA accelerators are not yet tested.

What we do NOT claim

• Galahad-0.5B is not a leaderboard model — it loses to comparable open baselines, by design (it's the cheap, open, inspectable proof substrate).
• The speedup is a long-context result; it is not "always faster."
• Cross-architecture = lossless migration, not full-sequence generation equivalence.
• Absolute hashes are GPU-architecture-specific; the property (graft == your own prefill) is universal.

Not in this repo

• The Taliesin engine (proprietary). The property is verifiable; the method is closed.
• Raw reference logit dumps (ref_hf.json / ref_llamacpp.json, ~39 MB) — available on request.

Open model: https://huggingface.co/Corbenic/Galahad-0.5B-base · Merlin: https://github.com/corbenicai/merlin-community + arXiv:2605.09990 · https://www.corbenic.ai