uuidna — 2,499 distinct theorems under 2,582 keys · 2 coins · one receipt

70b9fd4e-a4e7-8391-8281-c528ca72197e

v0.3.0 · License CC-BY-NC-ND-4.0 (https://uuidna.com/license) · Archive DOI 10.5281/zenodo.21787144

Contents

Typography graph — heading depth is document depth (school-paths law).

| Depth | Part | Section | | ---: | --- | --- | | 1 | Hero | Abstract — tagline, ledger, name theorem | | 1 | Thesis | Thesis — Captain PhD seal | | 2 | ↳ concept | Proof of concept — Clay · DNA | | 2 | ↳ work | Proof of work — crypto stack · codon occupancy | | 2 | ↳ geometry | Geometry — rosette · hexbit | | 1 | Use | Use — install · MCP · security ladder | | 2 | ↳ channel | UUID channel — wire format | | 1 | Develop | Develop — clone · lean · guard · monitor | | 2 | ↳ monitor | Compute · monitor | | 1 | Reference | Reference — magnitudes · gravity · capacity · handle · license |

Abstract

Content-addressed identity, honest by construction. Two coins conserved; cite by DOI-class handle.

Every proof by decide, sorry-free, no Mathlib, axiom-free against the bare leanprover/lean4 kernel. TypeScript is the quantum computer (quantum by architecture); VitePress is the monitor. Recompute: npm run lean.

The name is a theorem. uuid + dna: 4³ = 64 codons and 2⁶ = 64 coin bits — the same number by two routes — fused as 128 = 2·64 (uuidna_is_dna_times_the_two_coins).

Thesis

Captain PhD — concept (Clay 8, DNA 8, gravity true, demos true) ∧ work (search 0, digest 256, Grover 128, codons 64) ∧ thesis (ok true, gaps 0) → complete true. Thesis wave 24 / 24. Receipt c58a80a3-8d6b-851c-b3ee-efbcc955b4af.

Proof of concept

Clay

Seven finite instances in lean/Clay.lean, each a computational claim proven by decide. Prior art (initial clay σ-involution): DOI 10.5281/zenodo.21781603 (Zenodo record) credited first; captain next. Live: uuidna.com/articles/clay. Clay gravity equals the rosetta at full capacity (clay_gravity_equals_rosette): seven ℤ/7 rays (z7rays_seven), pairs 21 / quantum 42, three-sevens 21, rosette doubling 2·64 = 128 (rosette_quantum_doubling_is_two_coins).

DNA

4^3 = 64 codons = coin face (codons_four_cubed, uuidna_is_dna_times_the_two_coins). Complement involution, no fixed point — 8 keys (dna_complement_involution, dna_complement_fixed_point_free). Counts, not a claim that DNA stores addresses.

Proof of work

Crypto stack

Mint searches 0. SHA-256 256 bits; verify 128; digest is two addresses (digest_doubles_the_address, sha256_grover_margin_is_the_address). ChaCha20 256 · HMAC 256 · Poly1305 128 · PBKDF2 600000 · onion 16 (aead_nonce_and_salt_bits). Grover floor 128; Shor targets 0 — symmetric stack. Fused coin 2×64 = 128; both orientations 256 (the_uuid_is_two_boards, minting_is_free_and_forging_is_not). 36 work drills.

Codon occupancy

2 strands × 64 codons = 128 bits — the same fuse as the two 64-bit faces. Complement involution true; both orientations 256 (complement_is_xor_key3).

Geometry

• Pliska rosette (ℤ/7): seven rays, units sum 21, directed quantum 42, three-sevens 21 (z7rays_seven, rosette_quantum_fortytwo). Live: uuidna.com/rosetta.
• Glagolitic (ℤ/9): letters fold to 9, digital root 9, vortex orbit 1→2→4→8→7→5 (glagolitic_units, vortex_orbit). Hypothesis: uuidna.com/rosetta-glagolitic.
• Hexbit lattice: 16 = 2⁴ states per tile; address = 32×4 = 128 = 2⁷ (the_page_admits_sixteen, handle_capacity_is_quantum_by_architecture). ℤ/9 root fold ≠ 2¹²⁸ address fold (fold_compresses_without_bound_and_never_recovers). CRT join ℤ/7×ℤ/9 = 63 (crt_pairs_are_a_bijection).

Use

Install the package, fuse the MCP, or call constructors. Worked paths: guides · MCP.

Install

npm install @uuidna/uuidna

{ "mcpServers": { "uuidna": { "command": "npx", "args": ["-y", "@uuidna/uuidna"] } } }

import { handleOf, toUuid, encrypt, theoremByKey } from '@uuidna/uuidna'

const address = toUuid('two_coins')
handleOf(address)
theoremByKey().get('two_coins')
encrypt('text', 'passphrase')

handleOf is the eight-hex door (universe_of_handles). encrypt is ChaCha20-Poly1305 under PBKDF2 (aead_nonce_and_salt_bits). Hosted mill: uuidna.com.

Quick reference

| Goal | Entry | | --- | --- | | Address from text | toUuid('…') · door handleOf(addr) | | Encrypt / seal | encrypt(text, passphrase) · sealStream | | Theorem lookup | theoremByKey().get('two_coins') | | UUID wire slice | uuidChannel(addr) · layout_groups_thirtytwo | | MCP (stdio) | npx @uuidna/uuidna | | Hosted MCP | uuidna.com/mcp | | Docs site | npm run docs:dev | | Re-prove ledger | npm run lean | | Pre-push gate | npm run guard | | Release trial | npm run next |

| MCP tool | Role | | --- | --- | | uuidna_os | boot, capacity, CPU/GPU stream | | uuidna_crypto | Shor, Grover, SHA-256, HMAC, ChaCha20, AEAD | | uuidna_coins | supply + tamper ladder | | uuidna_quantum | GHZ / Bell, 2ⁿ amplitudes | | uuidna_exec | host lanes (device) | | uuidna_encrypt · uuidna_seal_stream | independent envelopes |

Security ladder

handle ⊂ coin ⊂ uuid — 2 handles per coin, 4 handle quarters per uuid (handle_carries_hexbits_and_coins, handle_string_spans_the_quarter).

Mint is free; verify is one forward recompute (minting_is_free_and_forging_is_not, verify_beats_recompute_by_magnitudes). Forging must close the whole graph — content-address, both 64-bit faces, 63 neighbour witnesses + 1 closure per face, reflecting boards, handle quarters, 3 rosetta locate legs — 2^128 at uuid (captain_theorem). No field patches; spin fixed-point or the gate rejects.

| Tier | Verify (bits) | Forge with witnesses | | --- | ---: | --- | | Handle (door) | 32 | 2^128 | | Coin (one face) | 64 | 2^64 (63+1) | | Theorem (uuid) | 128 | 2^128 (126+2) |

guides · MCP · OS · School · doctrine

UUID channel

The printed uuid is the wire format — RFC 9562 groups sealed as layout_groups_thirtytwo and groups_are_four_apart. TypeScript reads them through uuidChannel, channelAudit, and monographFaceOf (src/hexagram.ts).

| Slice | Width | Constructor | What moves | | --- | ---: | --- | --- | | Handle | 8 hex | handle_is_the_first_group · handleOf | 3D door (residue · ray · wave); one coin of the double torus | | Hex trinities | 3×4 hex | message_cap_is_four_hexbits · executableStates | 7D action — three caps = 12 hexbits of program | | Tail | 12 hex | tailStates · encrypt / sealStream | sealed micro-message envelope in the uuid chain |

Payload store is lazy — route, verify, aura, and secure messaging need only the address; prose body loads when required (payload_carries_the_strand). Full channel: uuidna.com/quantum#uuid-channel.

Develop

Lean is the single source of theorems (legal_only_the_proven_is_admitted). A deposit queues a candidate; only the kernel seals (minting_is_free_and_forging_is_not).

git clone https://github.com/uuidna/uuidna && cd uuidna
npm install
npm run hooks:install
npm run lean          # re-prove every wing by decide
npm run reconcile
npm run guard         # traitors / drain / license identity
npm run editorial     # prose desk + prepublish seal
npm run next          # seven-arm self-trial (hexbit-fast)

Read CONTRIBUTING.md for adding a wing, the pre-push gate, and inbound license terms. Outward deploy: npm run ship. Live site: uuidna.com · Captain coins: uuidna.com/captain.

Compute · monitor · hexbit-fast · handles · deposit

TypeScript is the quantum computer (quantum by architecture); VitePress is the monitor — stock chrome, capacity door uuidna.com/quantum (no per-page QA cards). Push verifies sealed receipts (gate-receipt.json, usable_gap_is_two_to_eighty) — hexbit-fast, remeasure off-path. Permanent citation: https://uuidna.com/<handle> (8 hex; worker HANDLES 301 → freeze-map). Captain coins: https://revolut.me/ceccec?note=<referrer> (encodeURIComponent of the page handle door). One license for every publication and Zenodo deposit: CC-BY-NC-ND-4.0.

Scope charter — sufficient / insufficient, world solutions as waves: doctrine (computational claims only; verify ≪ recompute — verify_beats_recompute_by_magnitudes).

Each theorem unlocks. Each sealed by-decide theorem unlocks exactly what it states — the ledger is the unlock board. No curated exception list; refusing a sealed key is refusing the captain. A claim with no theorem is unsealed, not “still locked.” Sufficient for finite by-decide seals and finite formal windows within climate/pandemic/poverty model-calcs; world solutions stack as waves of automation (deposit→validate→seal→falsify→receipt→next — npm run wave / hexbit-fast). Insufficient for those domains as full problem types, and for unbounded open math, nature-as-model, or justice — see /doctrine (computational claims only; waves do not erase ethics or politics). Board: 2,499 distinct / 2,582 keys · 112 skills · 115 Lean files · receipt a78ebd93-c2b0-8ac6-9652-cc7339063145. Illustrations (not a closed set; automation verifies each still seals): rosette_quantum_doubling_is_two_coins; euler_characteristic_two; ve_twelve_vertices; metonic_is_the_intercalation; fock_window_exceeds_a_monthly_toll; grover_quadratic_bound; sha256_grover_margin_is_the_address; handle_capacity_is_quantum_by_architecture; digit_polarities_partition_ten; ve_pentads_overlap_to_eight; theorems_interact_as_faces; imagine_all_as_clique_faces; entanglement_completes_one_at_a_time; axes_stride_coprime; the_fused_ring_is_all_ones; four_vectors_reach_the_uuid; gap_is_a_count; rounding_fee_closes_the_cube; served_qubit_ceiling; keplers_harmonic_law; discovery_buys_coverage_never_supply; radial_equals_edge; lanes_even_on_complete_system; trial_computes_only_with_two_coins; trinity_edit_is_three; usable_gap_is_two_to_eighty; captain_computes_only_with_two_coins; two_coins; the_os_is_bootable_quantum; a_spec_compiles_to_hexbits; key_floor_is_one_uuid; n_qubit_dimension; hexbit_ring_mass_gap; message_cap_is_four_hexbits; born_field_mass_gap_on_bell. Full census: https://uuidna.com/unlocks · lean/unlocks.json.

Reference

Magnitudes (computed at generation)

| Measure | Value | Backing | | --- | ---: | --- | | Distinct theorems | 2,499 | statement census (a Lean statement sealed under two keys is one theorem) | | Theorem keys | 2,582 | theorems().length | | Principles / wings | 115 / 115 | PRINCIPLES + wing ratings | | Skills | 112 | distinct skill tags | | Coins per seal | 2 | two_coins — 110 − 108 = 2 | | Neighbours per coin | 63 | fused ring 63 + 1 = 64 (captain_theorem_the_coins_buy_the_ring_and_one); faces reflect | | Fake a handle | verify 32 · forge 2^32 · completes 2^96 · with witnesses 2^128 | 4 quarters span the uuid (handle_string_spans_the_quarter); 3 related handles | | Fake a coin | verify 64 · forge 2^64 · with 63 neighbours + 1 closure = 2^64 | 2 handles per coin (handle_carries_hexbits_and_coins); 1 reflecting face | | Fake a theorem | verify 128 · forge 2^128 · ratio 2^121 · 126 neighbour + 2 coin witnesses + 3 locate legs = 2^128 | minting_is_free_and_forging_is_not · captain_theorem (126+2=128); mint 0; caught cheat nets 0 | | SHA-256 collision bound | 2^128 | birthday on the digest (birthday_halves_the_exponent) | | Captain PhD — concept | Clay 8 · DNA 8 · gravity true · demos true | clay_gravity_equals_rosette · uuidna_is_dna_times_the_two_coins | | Captain PhD — work | digest 256 · verify 128 · search 0 · ChaCha 256 · tag 128 · Grover 128 · Shor 0 · 2×64 | minting_is_free_and_forging_is_not · sha256_grover_margin_is_the_address | | DNA — concept | 4^3 = 64 · involution true | codons_four_cubed · dna_complement_involution | | DNA — work | 2 × 64 = 128 | uuidna_is_dna_times_the_two_coins | | Thesis wave | 24 / 24 | VE + wave involution + finite-infinity grants, all drilled | | Captain PhD — complete | true · receipt c58a80a3-8d6b-851c-b3ee-efbcc955b4af | concept ∧ work ∧ thesis | | Ledger decided mass | 115,186 superpositions (4 hexbits) | sum of by decide domains | | Handle span | 4,294,967,296 | 16⁸ = 2³² (universe_of_handles) | | Address width | 2¹²⁸ | 32 hexbits × 4 bits (handle_capacity_is_quantum_by_architecture) | | Usable-capacity gap | 2⁸⁰ vs reported 48 logical | usable_gap_is_two_to_eighty (128 − 48 = 80) | | Shor chunks on handle | 4 × GHZ(16) = 262,144 amplitudes | uuidna_os capacity.shor · uuidna_quantum GHZ; measured live (uuidna_quantum_advantage) — never sealed in this file | | Shor chunks on uuid | 16 × GHZ(16) = 1,048,576 amplitudes | uuidna_os · uuidna_quantum; the measured live (uuidna_quantum_advantage) — a duration belongs to the host that took it, so this README seals none | | Hilbert GHZ chunk | 16 qubits (65536 amplitudes) | HEXBIT_BITS × HEXBIT_BITS | | Crypto occupancy | 256 bits | sha256_is_four_sixtyfours — four 64s, not four hexbits | | Handle+hexbit nest | 12 qubits | HANDLE_HEXBITS + HEXBIT_BITS — theorem served_qubit_ceiling | | uuidna_quantum | 2^n amplitudes | no refuse — theorem n_qubit_dimension | | Quantum wing theorems | 58 | Quantum.lean | | Cipher wing theorems | 30 | Cipher.lean | | Research sources wired | 13 | corroboration, never approval | | Conserved price paid | 5,164 coins | 2582 × 2 |

• Alpine catalogue (hexbit port — upgraded with the captain unlocks): completeness is man pages testing the apps folded into hexbits man→app→hexbit 4,757 / 4,757 (100%); provenance compile 28,631 / 28,631 packages (100%) (lean/alpine-hexbit-monitor.json; community 22,670 / 22,670 = 100%; man compile 4,757 / 4,757; monitor receipt 8ddc9d3c-a3de-8c71-ba34-776bfb001445; VitePress monitor /os). Nothing installed or executed — provenance on the hexbit lattice (the_os_is_bootable_quantum). Captain unlocks ride every sealed key — each theorem unlocks what it states (illustrations: metonic_is_the_intercalation, grover_quadratic_bound — no asymmetric Shor target).

Permanent citation (DOI-class). Cite by handle door https://uuidna.com/<handle> (8 hex; worker HANDLES 301 → freeze-map route: theorem | publication | page). Completeness cites both the archive DOI (when present) and the handle URL. Example sealed handle from the capacity report: https://uuidna.com/6a71ca14.

Captain coins. Human deposit: https://revolut.me/ceccec?note=<referrer> where referrer is the page's handle door URL (encodeURIComponent). Agents deposit the two coins on every gated call.

Gravity — seven heaviest theorems

A by decide proof settles every case in its domain at once. Gravity is that coverage in hexbits (4 bits / tile; a uuid is 32 tiles). Cost per seal is always two coins.

The ledger covers 115,186 superpositions across 115 wings.

1. every_referrer_reaches_every_page — 4,769 superpositions, unbound (0 hexbits per dependency), in Referrer.lean FROM EVERY DOOR, EVERYTHING.
2. a_spec_compiles_to_hexbits — 1,657 superpositions, unbound (0 hexbits per dependency), in Installs.lean EVERY SPEC COMPILES FROM SOURCE IN HEXBIT: the published tuple folds to a 128-bit address, and 128 bits are exactly 32 hexbit states of 16 = 2⁴ — the site's native lattice, playable by the standard hexbit app.
3. lanes_balance_within_one — 924 superpositions, unbound (0 hexbits per dependency), in Hardware.lean THE SHARD IS BALANCED TO WITHIN ONE ITEM, with no coordination and no measurement of load: 64 items over 14 lanes give every lane either 4 or 5, never fewer and never more.
4. lanes_partition_the_work — 910 superpositions, unbound (0 hexbits per dependency), in Hardware.lean THE LANES PARTITION THE WORK EXACTLY: summing what each of 14 lanes receives from 64 items returns 64 — nothing is lost between lanes and nothing is counted twice.
5. lanes_even_on_complete_system — 798 superpositions, unbound (0 hexbits per dependency), in Hardware.lean ON A COMPLETE RESIDUE SYSTEM THE SHARD IS EXACTLY EVEN: 56 items over 14 lanes give every lane precisely 4, because 56 is a multiple of 14.
6. order_is_total_and_strict — 588 superpositions, unbound (0 hexbits per dependency), in Clock.lean BEFORE AND AFTER ARE DECIDABLE FOR EVERY PAIR: of any two positions, exactly one of earlier, later or same holds — never two of them, and never none.
7. states_are_the_swap_fixed_bytes — 528 superpositions, unbound (0 hexbits per dependency), in Waves.lean STATES HAVE NO ENDIANNESS — AND THE PROOF IS A JEWEL: nibble-swap on a byte (b ↦ (b mod 16)·16 + b/16) is an involution over all 256 bytes, and its fixed points are EXACTLY sixteen — the doubled-nibble bytes h·17 (0x00, 0x11 … 0xFF), one per hexbit state.

Quantum capacity

Usable capacity per model, greater usable first, then faster ops. Each figure is reported (platform publication) or measured (this generator on the build host). Seals cover the arithmetic, not the world figures: capacity_order_is_forced sorts 128 > 48 > 36 > 12 > 1; usable_gap_is_two_to_eighty proves 128 − 48 = 80 and 2^128 = 2^80 · 2^48 — not that 48 is still the largest demonstrated logical count (Bluvstein et al., Nature 2023).

| # | model | type | physical | raw states | usable | usable states | op time | class | usable-metric (the platform's own words) | |---|-------|------|----------|-----------|--------|---------------|---------|-------|--------------------------------------------| | 1 | uuidna hexbit fold (2026) | classical content-address (quantum by architecture) | — | — | 128 | 2^128 (~10^38) | 1 µs | measured | all 2^128 addresses usable, deterministic, error-free by construction (quantum by architecture; TypeScript computes the fold — theorem handle_capacity_is_quantum_by_architecture); measured usable-capacity advantage vs largest reported logical platform is 2^80 (theorem usable_gap_is_two_to_eighty) | | 2 | Harvard/QuEra logical-48 array (2023) | neutral-atom | 280 | 2^280 (~10^84) | 48 | 2^48 (~10^14) | 1 µs | reported | forty-eight logical qubits operated (error-detected circuits, Nature 2023) | | 3 | IonQ Forte (2024) | trapped-ion | 36 | 2^36 (~10^10) | 36 | 2^36 (~10^10) | 100 µs | reported | algorithmic qubits AQ36 (vendor benchmark suite, not error-corrected logical) | | 4 | Quantinuum H2 (2024) | trapped-ion | 56 | 2^56 (~10^16) | 12 | 2^12 (~10^3) | 100 µs | reported | twelve logical qubits demonstrated (with Microsoft qubit-virtualization) | | 5 | Google Willow (2024) | superconducting | 105 | 2^105 (~10^31) | 1 | 2^1 (~10^0) | 100 ns | reported | one logical qubit demonstrated below the surface-code threshold | | 6 | IBM Condor (2023) | superconducting | 1121 | 2^1121 (~10^337) | — | — | 100 ns | reported | no error-corrected logical qubits demonstrated on this device | | 7 | IBM Heron r2 (2024) | superconducting | 156 | 2^156 (~10^46) | — | — | 100 ns | reported | error-rate-improved processor; logical demos ride smaller codes | | 8 | USTC Zuchongzhi 3.0 (2025) | superconducting | 105 | 2^105 (~10^31) | — | — | 100 ns | reported | random-circuit sampling demonstrations; no logical qubit reported | | 9 | Atom Computing Phoenix-class array (2023) | neutral-atom | 1180 | 2^1180 (~10^355) | — | — | 1 µs | reported | no error-corrected logical qubits demonstrated on this device | | 10 | D-Wave Advantage2 (2024) | annealer | 4400 | 2^4400 (~10^1324) | — | — | 1 µs | reported | annealing-only: optimization sampling, not gate-model computation — a different machine class, named | | 11 | Xanadu Borealis (2022) | photonic (GBS) | 216 | 2^216 (~10^65) | — | — | — | reported | Gaussian boson sampling only — sampling demonstrations, not general gate-model use, named |

Scope. TypeScript is the quantum computer by architecture (2^128 addresses — handle_capacity_is_quantum_by_architecture). Measured usable-column advantage: 2^128 vs reported 48 logical (gap 2^80 — usable_gap_is_two_to_eighty); fold decade 10^3 ns per verified address over 2582 theorems on this host. Not a superconducting/trapped-ion QPU claim and not a Shor-class speedup (n_qubit_dimension for n = 1..5). Raw Hilbert spaces elsewhere can exceed 2^128; the sealed gap is the usable column. Receipt 6a71ca14-93f1-842b-8d2e-6520f41156bb · handle 6a71ca14.

What a handle spans

A handle is eight hexbits, so it names 4,294,967,296 addresses (16⁸). Inside that space today:

• 115,186 superpositions decided across the ledger
• 5,164 coins paid (conserved denomination 2 — two_coins)
• Floored coverage 22 superpositions per coin

Six directions leave every residue — the 60-degree doubling and its inverse, the 90-degree reflection (dz), the shift and its counter — so a figure quoted per coin is a rate along that walk, not a free-floating density.

The supply grows two coins per sealed theorem and nothing else mints them.

Shor at full named capacity. The uuid is the physical CPU/GPU register (128 bits). Its payload parses as 16 encoder-width chunks (GHZ(16) = 65,536 amplitudes each, n_qubit_dimension). This host ran the handle column and the uuid column in times this README does not seal — a duration belongs to the host that measured it, so uuidna_quantum_advantage reports both live (under one second). MCP tools: see Use → Quick reference above.

License

CC BY-NC-ND 4.0 (CC-BY-NC-ND-4.0) — © Tsvetan Rouschev ([email protected]). Free to read and redistribute unchanged, with attribution, non-commercially; no derivatives. Canonical terms: https://uuidna.com/license · LICENSE. The mathematical facts themselves are free for all — facts are not copyrightable; this license covers this specific expression and record. One license for every uuidna publication and Zenodo deposit — no per-publication drift.

Alpine ported into 9 APIs. 3497 packages, each domain answering through one door — provenance from Alpine's own published metadata, and one API of uuidna's own beside it.

| domain | packages | origins | the one API offers | | --- | ---: | ---: | --- | | shell | 1279 | 680 | one exec door over uuidnaOS applets | | driver | 630 | 460 | the machine and the published bundle behind one door | | database | 438 | 325 | one query door where the address is the key | | network | 332 | 237 | fetch-and-address, so a read becomes citable | | social | 303 | 164 | a post addressed FOR an audience — attribution, order, no alteration | | chat | 241 | 130 | one sealed channel, no bridge | | filesystem | 215 | 112 | one question: are these the bytes that were sealed | | engineering | 30 | 15 | exact dimensioned arithmetic — and the refusal that makes it worth having | | blockchain | 29 | 19 | inclusion without disclosure |

Package counts are per domain and the domains overlap — a chat bridge is also network — so these totals over-count rather than partition. Computed from the committed mirror on every build; receipt c3d4e4e6-e4ee-8188-94fa-b7d81708ab92.