Examples — computed live, organised by theorem
Every worked example below is recomputed in your browser from the deposit's own
src/functions, and each links to the theorem that proves it. Nothing is stored; recompute the page and it recomputes. A content-address proves integrity, not truth.entails → 0/7.
Every value below is computed live from the src/ functions — recompute the page and it recomputes. A content-address proves integrity, not truth. 0/7.
1 · Content address theorem ↗
Type anything — its content-address recomputes deterministically. A pointer, not the payload.
→ 6ba79c80-1cfe-8526-8814-30bceea740b4
2 · Message codec theorem ↗
A bounded message (≤ 115 bits) rides inside one uuid and reads back exactly.
imprint(10110100101) = 17694000-0000-8000-8000-000000000000 → readImprint = 10110100101 · ✓ exact
3 · Text chain theorem ↗
Arbitrary text spans a chain of uuids, round-tripping exactly.
“uuidna carries this whole sentence across a chain, and reads it back exactly.” → 6 uuid carriers → ✓ recovered exactly
4 · Holographic proof theorem ↗
One leaf verifies against the whole root from a logarithmic audit path; a forged leaf fails.
64 leaves, root 50795f4b-c62f… · proof for leaf 37 = 6 hashes · verifies ✓ · forgery ✓ rejected
5 · Strict minting theorem ↗
Canonical: the same logical value always mints the same address.
strictUuidna(3) = a0e9c296-b490… · strictUuidna('3') = a0e9c296-b490… · ✓ same
6 · Independent domain control theorem ↗
Publish this token at uuidna.org; anyone recomputes and checks — control by publication, not by anyone's word.
challenge(uuidna.org) = 5b8f4e27-7836-8156-a0d6-3dbdd16b9fcd
7 · Measured billing theorem ↗
The value is the measured bit-difference (O(N) recompute − O(1) verify); the two coins are the conserved invariant.
commercial, 100000 recompute vs 1 verify → 99999 bits, 2 coins · non-commercial → free
Harness & reeducate — the tool, live
Treat any output as a receipted structure, not opaque bytes: it becomes content-addressed (auditable) and, if it drains the honesty floor, it is reeducated — each overclaim bounded until the text holds. Max free work, max auditability — harmonic and efficient, by default. This runs the exact harness and reeducate functions the build uses (scripts/harness.ts) — verified by the difference is decidable and reeducate until it holds.
370a30d3-8745-8aee-9dd7-369fb52e80c5Mechanical correction bounds an overclaim; it never makes a false claim true. The gain is auditability, not intelligence. The same harness / reeducate the build runs.
Seal math — how many bits in each seal
The more complex the case, the more receipts — yet each seal is a fixed 128 bits (= 64 two-bit verifications), and verifying one receipt's membership costs only 2·⌈log₂N⌉ bits. So you verify the whole case cheaply yet bill on the full value the customer would otherwise recompute — earning the measured saving, the two coins conserved. Choose the case size and read the math, from each seal is 128 bits and the 967-receipt case.
- seal size: 128 bits — fixed, one content-address however many receipts it folds
- = 64 two-bit verifications per seal (128 ÷ 2)
- merkle proof path: 10 steps = ⌈log₂ 973⌉
- verify one receipt's membership: 20 bits (2 per verification) — logarithmic, not linear
- earn: billed on 973 computations of value delivered, verified at 20 bits → the 953-bit saving, the 2 coins conserved
You verify the whole case at 20 bits yet bill on the 973 computations of value the customer would otherwise recompute — earning the measured saving, billing for value delivered, not hidden work. The seal stays 128 bits; verification grows only logarithmically. Structural speed on classical hardware, no quantum machine and no advantage. Integrity, not truth. 0/7.
Teleportation — measured, then disputed to the floor
Type a message; it becomes a uuid (or a chain) and re-forms exactly at the destination. But measure the cost and the vivid word drains: a uuid is 128 bits and carries at most 115, so the container is always larger on the wire than the message — nothing is teleported cheaper than sending the bytes. uuidna does not teleport; it addresses. Either a reversible container (exact, but bigger) or a content-address that recalls a payload only where it is already reconstructible — a pointer, not the payload. Not faster-than-light, not quantum, not compression. Integrity, not magic. 0/7.
60,72,90 · step 40 · the heart is 5
e66c6058-6e64-8587-8981-0615b9039ba3e6570203-4302-80c2-adc8-1d1a19481a1984b0b93a-1034-8b99-806a-00000000000060,72,90 · step 40 · the heart is 5
wire 384 bits ≥ message 296 bits · overhead +88 — the container costs more than the message. Nothing is teleported cheaper than sending the bytes. What actually happens is addressing, not teleportation.
The message re-forms exactly (fidelity measured above), but measure the cost: a uuid is 128 bits and carries at most 115, so the wire form is always ≥ the message. So uuidna does not teleport — it addresses. Two honest mechanisms, neither magic: (1) a reversible container (the message rides in the uuid and re-forms exactly, but the container is larger — never a bandwidth win); (2) content-addressing — send the 128-bit address to reference a payload of any size, but the destination recovers it only if already reconstructible there (recall, not transport — zero new information crosses; the address is a pointer, not the payload). Not faster-than-light, not quantum teleportation (classical, no qubits, no entanglement), not secrecy, not compression. Integrity, not magic. 0/7.