███████╗ █████╗ ███╗ ███╗ █████╗ ██╗ ██╗██╗ ██╗██╗ ██╗████████╗ █████╗ ███╗ ███╗ ██╔════╝██╔══██╗████╗ ████║██╔══██╗╚██╗ ██╔╝██║ ██║██║ ██╔╝╚══██╔══╝██╔══██╗████╗ ████║ ███████╗███████║██╔████╔██║███████║ ╚████╔╝ ██║ ██║█████╔╝ ██║ ███████║██╔████╔██║ ╚════██║██╔══██║██║╚██╔╝██║██╔══██║ ╚██╔╝ ██║ ██║██╔═██╗ ██║ ██╔══██║██║╚██╔╝██║ ███████║██║ ██║██║ ╚═╝ ██║██║ ██║ ██║ ╚██████╔╝██║ ██╗ ██║ ██║ ██║██║ ╚═╝ ██║ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝
PCMP
Floating-point inference is non-deterministic across hardware. PCMP terminates that. Every logit stream canonicalized, committed, and reconstructible — byte-identical across CPU, GPU, and batch. No approximations. No overrides. No excuses.
per inference
PCMP · SPCMP · CAGM · FADS · INFERENCE
reconstruction
artifacts
portability
What Samayuktam Is
Samayuktam solves a problem that has quietly undermined every verifiable AI system built to date: the same neural network, run on different hardware, produces different outputs at the bit level. This makes cryptographic verification of AI inference and training mathematically impossible — until now.
Samayuktam is a deterministic verification protocol that canonicalizes floating-point representations across CPUs, GPUs, and TPUs, producing a hardware-agnostic cryptographic fingerprint for any neural network's inference or training run. The same model, the same input, the same hash — regardless of which chip ran it.
Verified across GPT-2, BERT-base, and LLaMA-style architectures.
Technical Specification
Samayuktam is a deterministic inference verification protocol for neural networks running on heterogeneous hardware. At its core, PCMP (Predictive Canonical Monotonic Permutation) defines a bijective, order-preserving mapping of IEEE-754 float32 values into a uint32 space, enabling a canonical total ordering that is bit-identical across any CPU, GPU, or TPU.
SPCMP, its strict profile, adds a mandatory preprocessing pass that collapses all NaN payload variants to a single canonical quiet NaN and all negative zeros to positive zero, eliminating the four primary sources of cross-hardware floating-point divergence: FMA sub-LSB jitter, signed-zero contamination, NaN payload variants, and near-bucket-edge exponent shifts.
The Samayuktam Inference Engine wraps this canonicalization around every layer boundary of a running neural network, producing a 32-bit FNV-1a logit fingerprint provably bit-identical regardless of whether the model ran on an NVIDIA H100, a Google TPU v5e, or an x86 CPU.
Floating-Point Inference Is Fundamentally Non-Deterministic
Every major AI lab ships models that produce different numerical outputs on different hardware. Not approximately different. Actually different. CPU vs GPU. Driver A vs Driver B. Batch of 1 vs batch of 32. The same model, the same weights, different bits.
This is not a bug. IEEE-754 floating-point arithmetic is non-associative. Operation reordering, FMA fusion, subnormal flushing, signed-zero behavior, NaN propagation — all of these produce legitimate but divergent results. No existing standard resolves this for inference-scale logit streams.
Four-Layer Verification Stack
Three-Phase Canonical Pipeline
Evaluated on Real Transformer Workloads
Tested on real transformer inference across heterogeneous hardware execution environments. Not synthetic benchmarks. Not toy models. Production-scale inference.
cmpWhat PCMP + SPCMP Terminates
10-Step Verification Algorithm
0x01. No other value accepted.
Samayuktam Protocol Suite — Running Now
Four active Hugging Face Spaces. Open source. Verifiable. No accounts required.
verify.py — The Canonical Verifier
Production Python implementation. Runs locally. No dependencies on this page. Pure protocol.
Standalone reference implementation of the full SPCMP verification algorithm.
Reads a .pcmp artifact, performs all 10 verification steps, validates the
Canonical Value Domain, checks the Merkle root, and emits structured output.
This is the ground-truth verifier — what all other implementations must match.
pip install zstandard
python verify.py artifact.pcmp
python verify.py --info artifact.pcmp
python verify.py --json artifact.pcmp
Samayuktam Inference
The inference runtime is the terminal enforcement boundary of the Samayuktam protocol stack. It applies SPCMP canonicalization directly inside the forward pass — between every layer, at every activation boundary.
Every activation tensor is canonicalized before it enters a layer and corrected after it exits. The logit stream produced at the final layer is guaranteed to hash identically across any compliant hardware, regardless of FMA fusion, NaN payload, signed-zero behavior, or driver-level float rounding.