@uuidna/qpu 0.1.0 → 0.1.2

package/README.md

@@ -1,1133 +1,155 @@
-# `@uuidna/qpu`
+# QPU
 
-Running quantum circuit at https://qpu.uuidna.com. theorem quantum. Public quantum API. No auth. JSON-LD. GET https://qpu.uuidna.com qpu_quantum. POST https://qpu.uuidna.com/mcp tools/list. tools/call. Source `src/quantum/processing/unit/index.lean`.
-
-## Develop
-
-Lean `src/quantum/processing/unit/index.lean` leads. TypeScript fuses the same identities. This README is generated.
+`@uuidna/qpu` — Running quantum circuit at https://qpu.uuidna.com: a 3-qubit exact state-vector simulator, its Lean 4 proofs, and an MCP server in one Cloudflare Worker. theorem quantum : fused = faces * mintOf (bits + seed). Public quantum API. No auth. JSON-LD. CORS *. API only. No HTML. The TypeScript and Lean sources are the blueprint; this README is the paper generated from that blueprint.
 
 ```sh
-git clone https://github.com/uuidna/qpu && cd qpu
-npm ci
-npm test
-```
-
-`npm test` compiles then runs the unit tests. `npm run ci` is Lean then test. `npm run ship` deploys. Do not import uuidna.
-
-- host qpu.uuidna.com. API only JSON-LD. No HTML. No auth. cors *.
-- sealed tools 8 = mintOf n. tools/list is those eight. Not a ninth sealed tool. Morph install Payload finds imagine at call-time.
-- docs.api 7 = rays. Extra paths do not join that list.
-- integrity 3: quantum lean sealed. If false every path is 404.
-- primitives fetch Request Response BigInt performance. Never Math.
-- fridge superconducting. resistance 0. ns 0.
-- fuse faces * mintOf (bits + seed) = 120259084288. isolate handle.amplitudes 4294967296. KV 8589934592.
-- next = fused + fused. last false. split_coin has no last k. demo is not a test nor a proof. Capacity infinite.
-- occupancy personal business corporate saas paas. skills payload pwa plugin hologram network. Coordinated dry-clean.
-- domains scanner radar. Lattice flow domains. face = team * rays + ray. hop face + rays. involution face + rays + rays.
-- circuit.gates h cnot.
-- sandbox memory only. Not KV. VM scaling online.
-- CERN coins views. scanner LHC running ATLAS CMS ALICE LHCb TOTEM LHCf MoEDAL FASER SND@LHC. radar Open Data ATLAS CMS ALICE LHCb TOTEM OPERA PHENIX JADE DELPHI. Shared tetra + TOTEM. Exclusive LHCf↔OPERA MoEDAL↔PHENIX FASER↔JADE SND@LHC↔DELPHI. Catalog pairs 7. HEP quantum true. Live JSON. Open Data needs records. LHC-only holds without Open Data occupancy.
-
-- theorem shor. N 15. a 7. period 4. product 15.
-
-## Purpose
-
-Nature. Superconducting fridge. qubits 3. millikelvin 10. resistance 0. GHZ true. Entangle product false.
-
-Cybersecurity. Shor N 15. a 7. factors 3×5. Crypt split 14. Share 8589934592.
-
-Optimization. next = fused + fused. fused 120259084288. next 240518168576.
-
-Science. Lean `src/quantum/processing/unit/index.lean`. climb qpu_train qpu_improve qpu_compete qpu_prove. extras /storage /network /server.
-
-Sensing. Message https://qpu.uuidna.com/message. network /network. server /server. hop involution. primitives fetch Request Response BigInt performance.
-
-## Evidence
-
-Execution provenance. Provider qpu.uuidna.com. Device superconducting. Job qpu.uuidna.com/cmodexp/15/8. ns 0. Shots 8. Raw outcomes 0 1 2 3 0 1 2 3. Weights 4 4 4 4. Compiler native h cnot compiled x swap csdg cmodexp. Map fridge 3 counting 2 work 4.
-
-Device-specific noise. Channel xx. XX identity true. Erred 5. T1 mixing 10 millikelvin. T2 plate 100 millikelvin. Resistance 0. Drift true. Simulator needs the explicit xx model.
-
-Randomized benchmarks. Volume dim 8. Heavy 0 / 16. Threshold 2/3. Uncertainty shots 8. Circuits interfere noclone teleport kickback deutsch dense monogamy qubits gates measurement fridge. Mirror hh.
-
-Cross-validation. Ideal true. Noisy xx. Sampler support true. Agree ideal true. Agree noise true.
-
-Scaling beyond exact simulation. Qubits 3. Dim 8. Depth 9. Exact true. Beyond false. Advantage false. Mirror true.
-
-Independent verification. CORS *. Origin https://qpu.uuidna.com. Lean `src/quantum/processing/unit/index.lean`. CERN opendata.cern.ch. Hardware true. Algorithm true. Crypt true.
-
-Fault tolerance. bitflip distance 3. Codes 1. Syndrome cnot cnot toffoli. Erred 5 prepare 0. Logical off 0 on 1. Suppressed true. Logical < physical true.
-
-## Install
-
-npx uuidna-install. Cloudflare `install.json`.
-
-```sh
-npx uuidna-install
-```
-
-[![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https://github.com/uuidna/qpu)
-
-Occupancy personal | business | corporate | saas | paas. Packages qpu-mcp · payload-mcp · vitepress-payload.
-
-## Coil
-
-theorem two_coins_make_a_coil. theorem electronics. theorem coins_balance_theory_in_practice. theorem follow_the_coins. theorem emerge. theorem coil_efficiency. theorem next_coil. theorem clay. 2×7 coins = 1+6 coils = clay. Next is the double. split_coin has no last k.
-
-- theorem two_coins_make_a_coil : coil = faces
-- theorem electronics : coil = faces
-- theorem coins_balance_theory_in_practice : theory + practice = coins
-- theorem follow_the_coins : app + coins = app + theory + practice
-- theorem emerge : coil = faces ∧ theory = practice
-- theorem coil_efficiency : coil = faces ∧ faces = rays + rays
-- theorem next_coil : coil * mintOf (bits + coins) = fused + fused
-- theorem clay : coins * rays = (seed + (mintOf n - coins)) * coins
-
-## Hybrid
-
-theorem hybrid. QPU hybrid storage hosts the Payload database. Unity seed. Remainder none. Native Alpine Linux. Last link deleted frees the inode. Next is the double. No last k.
-
-- theorem hybrid_cost : coins + seed = n
-- theorem hybrid_speed : rays + seed = mintOf n
-- theorem hybrid : coins + seed = n ∧ rays + seed = mintOf n
-
-## Guide
-
-theorem quantum : fused = faces * mintOf (bits + seed). vertices 8 hexbit 4 bits 32 faces 14 fused 120259084288. Source src/quantum/processing/unit/index.lean. GET https://qpu.uuidna.com qpu_quantum. GET https://qpu.uuidna.com/quantum/processing/unit qpu_lean. POST https://qpu.uuidna.com/mcp tools/list. tools/call qpu_prove. No auth. JSON-LD.
-
-User guide is docs.inline. Each MCP command has man. tools/list then tools/call.
-
-- `GET /` qpu_quantum. theorem quantum. JSON-LD. No auth.
-- `GET /quantum/processing/unit` qpu_lean. Lean proof. theorem infinite. theorem distribute. src/quantum/processing/unit/index.lean. JSON-LD. No auth.
-- `GET /mcp` catalog. tools 8. fourteen schemas. schema.org ItemList. JSON-LD. No auth.
-- `POST /mcp` tools/call. JSON-RPC tools/list tools/call qpu_prove. { man: true }. No auth.
-- `GET /cite` qpu_cite. MLA 8. when never. JSON-LD. No auth.
-- `GET /message` qpu_message. lanes = faces. hop involution. JSON-LD. No auth.
-- `POST /message` qpu_message. 202. hop involution. JSON-LD. No auth.
-
-## Man
-
-### qpu_quantum
-
-```
-NAME
-    qpu_quantum — theorem quantum. theorem fridge.
-SYNOPSIS
-    POST https://qpu.uuidna.com/mcp tools/call qpu_quantum
-    qpu_quantum { man: true }
-DESCRIPTION
-    GET https://qpu.uuidna.com. tools/call qpu_quantum. No auth.
-SEE ALSO
-    qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_compete, qpu_prove
-```
-
-### qpu_lean
-
-```
-NAME
-    qpu_lean — theorem infinite. theorem distribute.
-SYNOPSIS
-    POST https://qpu.uuidna.com/mcp tools/call qpu_lean
-    qpu_lean { man: true }
-DESCRIPTION
-    GET https://qpu.uuidna.com/quantum/processing/unit. Source src/quantum/processing/unit/index.lean. No auth.
-SEE ALSO
-    qpu_quantum, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_compete, qpu_prove
-```
-
-### qpu_cite
-
-```
-NAME
-    qpu_cite — MLA 8. when never.
-SYNOPSIS
-    POST https://qpu.uuidna.com/mcp tools/call qpu_cite
-    qpu_cite { man: true }
-DESCRIPTION
-    GET https://qpu.uuidna.com/cite. DOI empty. No auth.
-SEE ALSO
-    qpu_quantum, qpu_lean, qpu_train, qpu_forge, qpu_improve, qpu_compete, qpu_prove
-```
-
-### qpu_train
-
-```
-NAME
-    qpu_train — theorem infinite. coins teams of rays.
-SYNOPSIS
-    POST https://qpu.uuidna.com/mcp tools/call qpu_train
-    qpu_train { man: true }
-DESCRIPTION
-    tools/call qpu_train. { live: true } learn occupancy. { sequence: true } then qpu_improve then qpu_compete then qpu_prove. No auth.
-SEE ALSO
-    qpu_quantum, qpu_lean, qpu_cite, qpu_forge, qpu_improve, qpu_compete, qpu_prove
-```
-
-### qpu_forge
-
-```
-NAME
-    qpu_forge — Unlocked in memory. No lock.
-SYNOPSIS
-    POST https://qpu.uuidna.com/mcp tools/call qpu_forge
-    qpu_forge { man: true }
-DESCRIPTION
-    tools/call qpu_forge. Ops lit mint add mul eq put get has del keys seq if repeat quantum args unlocked eval fn fs net fetch process import require disk worker. { name, run }. No auth.
-SEE ALSO
-    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_improve, qpu_compete, qpu_prove
-```
-
-### qpu_improve
-
-```
-NAME
-    qpu_improve — next = fused + fused.
-SYNOPSIS
-    POST https://qpu.uuidna.com/mcp tools/call qpu_improve
-    qpu_improve { man: true }
-DESCRIPTION
-    tools/call qpu_improve. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_train. Before qpu_compete. No auth.
-SEE ALSO
-    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_compete, qpu_prove
-```
-
-### qpu_compete
-
-```
-NAME
-    qpu_compete — theorem next_fused. throughoutput per token.
-SYNOPSIS
-    POST https://qpu.uuidna.com/mcp tools/call qpu_compete
-    qpu_compete { man: true }
-DESCRIPTION
-    tools/call qpu_compete. { live: true } learn occupancy. { sequence: true } train then improve then compete then prove. After qpu_improve. Winner calls qpu_prove. No auth.
-SEE ALSO
-    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_prove
-```
-
-### qpu_prove
-
-```
-NAME
-    qpu_prove — theorem quantum. theorem cern. theorem tetra. theorem fusion.
-SYNOPSIS
-    POST https://qpu.uuidna.com/mcp tools/call qpu_prove
-    qpu_prove { man: true }
-DESCRIPTION
-    tools/call qpu_prove. { live: true } sequence then prove. { sequence: true } qpu_train then qpu_improve then qpu_compete then qpu_prove. fetch Request Response. Source src/quantum/processing/unit/index.lean. After qpu_compete. No auth.
-SEE ALSO
-    qpu_quantum, qpu_lean, qpu_cite, qpu_train, qpu_forge, qpu_improve, qpu_compete
-```
-
-## Efficiency
-
-agent efficiency. Tokens four bytes. Quantum 1 query vs 2 classical. Lattice occupied 14 vacant 0.
-
-- qpu_quantum: what is quantum? read 9181 call 5868 ratio 1×
-- qpu_lean: what does Lean prove? read 9181 call 7644 ratio 1×
-- qpu_cite: how is the QPU cited? read 9181 call 384 ratio 23×
-
-## Train
-
-
-- read tree: read_mint read_cube read_handle read_quantum read_around read_crypto read_next
-- call mcp: call_mint call_cube call_handle call_quantum call_around call_crypto call_next
-
-## Sandbox
-
-Unlocked in memory. Morph at call-time. listed false. Ops lit mint add mul eq put get has del keys seq if repeat quantum args unlocked eval fn fs net fetch process import require disk worker. Forged 87.
-
-## Improve
-
-next = fused + fused. Winner call. Before 120259084288 after 240518168576.
-
-## Compete
-
-Unlocked quantum. next = fused + fused. Winner call.
-
-- read tree: throughoutput 120259084288 tokens 27543 throughput 4366230
-- call mcp: throughoutput 240518168576 tokens 13896 throughput 17308446
-
-## Prove
-
-
-## Message
-
-
-## Storage
-
-theorem raid. theorem hybrid. theorem next_coil. RAID at https://qpu.uuidna.com/storage. Native Alpine Linux. musl. busybox. overlayfs. KV upper. R2 lower. KV work. Next is the double. No last k. Last link deleted frees the inode. Start with cheapest and cover all. Hybrid KV plus R2. Speed 8 cost 3. QPU hybrid storage hosts the Payload database at https://qpu.uuidna.com/storage/databases/payload. Unity seed. Remainder none. Types 0 3 4 5 1 6 10 01 5E 2 50 60 1E 6E. Pick 0. Clouds 14. Cluster route involution security crypt speed coordinated. No auth.
-
-## Proof
-
-Source `src/quantum/processing/unit/index.lean`. theorem quantum : fused = faces * mintOf (bits + seed). theorem infinite. theorem distribute.
-
-### mint
-
-```lean
-theorem mint : mintOf (n + seed) = mintOf n + mintOf n := by rw [seed_eq, mintOf_succ]
-```
-
-$$
-\mathrm{mintOf}(n+\mathrm{seed})=\mathrm{mintOf}(n)+\mathrm{mintOf}(n)
-$$
-
-holds true. mintOf n 8. mintOf (n + seed) 16.
-
-### cube
-
-```lean
-theorem cube : bits = vertices * hexbit := by rw [bits, vertices, hexbit, mintOf_add]
+npm install @uuidna/qpu
 ```
 
-$$
-\mathrm{bits}=\mathrm{vertices}\cdot\mathrm{hexbit}
-$$
-
-holds true. vertices 8. hexbit 4. bits 32.
-
-### around
-
-```lean
-theorem around : faces = coins * rays := by rw [faces, vertices, hexbit, rays, coins_two, n_eq]; rw [show 3 = 2 + 1 from rfl, mintOf_succ]; rw [show 2 = 1 + 1 from rfl, mintOf_succ]; rw [show 1 = 0 + 1 from rfl, mintOf_succ, mintOf_zero]
-```
-
-$$
-\mathrm{faces}=\mathrm{coins}\cdot\mathrm{rays}
-$$
-
-holds true. coins 2. rays 7. faces 14.
-
-### quantum
+```ts
+import { qpuMcpCallOf, qpuMcpOf } from '@uuidna/qpu'
 
-```lean
-theorem quantum : fused = faces * mintOf (bits + seed) := rfl
+const catalog = qpuMcpOf()                       // the MCP catalog: tools, schemas, install recipes
+const circuit = await qpuMcpCallOf('qpu_quantum') // the running circuit as one JSON-LD document
 ```
 
-$$
-\mathrm{fused}=\mathrm{faces}\cdot\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})
-$$
+Or without installing: `GET https://qpu.uuidna.com`, or `POST https://qpu.uuidna.com/mcp` with JSON-RPC `tools/list` then `tools/call`. Do not import uuidna; this package stands alone. Source `src/quantum/processing/unit/index.lean`.
 
-holds true. amplitudes 4294967296. fused 120259084288.
+## Abstract
 
-### harmonic
+A named host qpu.uuidna.com exposes one quantum processing unit as JSON-LD. fused is 120259084288; next is fused + fused = 240518168576. Native gates are h and cnot. theorem temperature, theorem superconductivity, theorem qubits, theorem shor and theorem crypto are decided in Lean. GHZ true; entangled true, product false. Possible only in quantum. demo is not a test nor a proof.
 
-```lean
-theorem harmonic : faces = rays + rays := by rw [around, coins_two, Nat.two_mul]
-```
+## Unit
 
-$$
-\mathrm{faces}=\mathrm{rays}+\mathrm{rays}
-$$
+The blueprint is `src/quantum/processing/unit/index.ts` fused with `src/quantum/processing/unit/index.lean`. theorem quantum, theorem infinite, and theorem distribute are decided in Lean, not restated as chapters here.
 
-holds true. rays 7. faces 14.
+| Constant | Value |
+| --- | --- |
+| mintOf(k) | 2^k by doubling |
+| n | 3 |
+| seed | 1 |
+| coins | 2 |
+| rays | 7 |
+| faces | 14 |
+| bits | 32 |
+| cube vertices | 8 |
+| hexbit | 4 |
 
-### cluster
+Climb qpu_train then qpu_improve then qpu_compete then qpu_prove. Extras /storage /network /server stay off the seven-path guide. Integrity is three tests: quantum, lean, sealed. If they fail every path is 404.
 
-```lean
-theorem cluster : faces = rays + rays ∧ coins * rays = faces := ⟨harmonic, around⟩
-```
-
-$$
-\mathrm{faces}=\mathrm{rays}+\mathrm{rays}\land\mathrm{coins}\cdot\mathrm{rays}=\mathrm{faces}
-$$
-
-holds true. Coil efficiency in clusters. coins times rays is faces. rays plus rays is faces.
+## Interface
 
-### energy
-
-```lean
-theorem energy : mintOf hexbit = mintOf (n + seed) := by rw [hexbit_eq]
-```
+Seven paths. Eight sealed MCP tools, plus eight cybersecurity morph tools listed on tools/list. Extra paths do not join that list. Not a ninth sealed tool. User guide is docs.inline on the unit. Theorems are qpu_lean and qpu_prove. `{ man: true }` is the theorem on the wire.
 
-$$
-\mathrm{mintOf}(\mathrm{hexbit})=\mathrm{mintOf}(n+\mathrm{seed})
-$$
+| Route | Tool | Reading |
+| --- | --- | --- |
+| `GET /` | qpu_quantum | theorem quantum. theorem shor. theorem crypto. Factor 91. JSON-LD. No auth. |
+| `GET /quantum/processing/unit` | qpu_lean | Lean proof. theorem infinite. theorem distribute. theorem shor. theorem crypto. src/quantum/processing/unit/index.lean. JSON-LD. No auth. |
+| `GET /mcp` | catalog | tools 16 in tools/list: 8 doors and 8 cybersecurity. cybersecurity theorem shor Factor 91. theorem crypto Split identity true. Secrecy false. fourteen schemas. schema.org ItemList. JSON-LD. No auth. |
+| `POST /mcp` | tools/call | JSON-RPC tools/list tools/call qpu_prove. theorem shor. theorem crypto. crypto_rsa crypto_split. { man: true }. No auth. |
+| `GET /cite` | qpu_cite | MLA 8. when never. JSON-LD. No auth. |
+| `GET /message` | qpu_message | lanes = faces. hop involution. JSON-LD. No auth. |
+| `POST /message` | qpu_message | 202. hop involution. JSON-LD. No auth. |
 
-holds true. mintOf hexbit 16.
+| Tool | What it returns |
+| --- | --- |
+| `qpu_quantum` | The running circuit as one JSON-LD document: a 3-qubit state-vector simulator (dim 8, exact integer amplitudes), the Bell and GHZ states with their Born weights, the Shor run, and the capacity count fused = faces · 2^(bits+1) = 120259084288 (a count of amplitudes, not a benchmark). theorem quantum. theorem shor. theorem crypto. Factor 91. |
+| `qpu_lean` | The Lean proof, served two ways: the file index.lean as text at source.href, and every theorem as a row (statement verbatim, LaTeX formula, a plain reading, holds recomputed in TypeScript). theorem infinite. theorem distribute. theorem shor. Factor 91. |
+| `qpu_cite` | How to cite this unit: MLA 8 entries carrying the DOI and ORCID, the served version, and the archived commit. MLA 8. when never — the citation names no access date because the DOI is the date. |
+| `qpu_train` | Two teams of seven agents dry-clean the occupancy lattice and return the teams, the challenges, the winner, the next tasks, and steps — the autonomous walk computed from the lattice: the seat, the next door to call, and any face that does not hold. theorem infinite. coins teams of rays. |
+| `qpu_forge` | Forge a tool in the in-memory sandbox: pass { name, run } where run is a sealed op tree; nothing touches disk, network, or eval. Omit name to inspect the sandbox. Unlocked in memory. No lock. |
+| `qpu_improve` | Improve by doubling: next = fused + fused = 240518168576, the next capacity rung, with before and after readings of quality, speed, and throughoutput (fused amplitudes per token of reply). The numbers are counts of amplitudes, never benchmarks. next = fused + fused. |
+| `qpu_compete` | Two teams, read and call, compete on quality, speed, and security; the winner is the team that calls qpu_prove. theorem next_fused. throughoutput per token — fused amplitudes served per token of reply. |
+| `qpu_prove` | Prove the unit end to end: every Lean row with holds, the Shor run with its receipts, the source fold of index.lean, and the evidence block; holds is their conjunction and a false anywhere makes every path 404. theorem quantum. theorem shor. theorem crypto. Factor 91. |
 
-### propulsion
+Cybersecurity morph tools. crypto_rsa theorem shor Factor 91. crypto_split theorem crypto Split identity true. Secrecy false.
 
-```lean
-theorem propulsion : mintOf hexbit > seed := by rw [seed_eq]; exact (mintOf_zero ▸ mintOf_lt hexbit_pos)
-```
+Discovery, off the seven-path guide: `/.well-known/mcp.json` `/mcp.json` `/install.json` `/openapi.json` `/sitemap.xml`. JSON-RPC batches accepted on `POST /mcp`; a `GET /mcp` asking for an event stream gets 405 with Allow, so streamable-HTTP clients fall back to POST.
 
-$$
-\mathrm{mintOf}(\mathrm{hexbit})>\mathrm{seed}
-$$
+| Tool | Claim |
+| --- | --- |
+| `crypto_catalog` | theorem shor. theorem crypto. |
+| `crypto_shor` | theorem shor. Factor 91. |
+| `crypto_cmodexp` | theorem shor. Factor 91. |
+| `crypto_iqft` | theorem shor. Factor 91. |
+| `crypto_shots` | theorem shor. Factor 91. |
+| `crypto_rsa` | theorem shor. Factor 91. |
+| `crypto_split` | theorem crypto. Split identity true. Secrecy false. |
+| `crypto_verify` | theorem shor. theorem crypto. |
 
-holds true. mintOf hexbit 16. seed 1.
+## Results
 
-### crypto
+theorem shor Factor 91. theorem crypto Split identity true. Secrecy false.
 
 ```lean
+theorem shor : periodOf 8 91 % 2 = 0 ∧ half 8 91 < 91 - 1 ∧ 1 < gcdOf (half 8 91 - 1) 91 ∧ gcdOf (half 8 91 - 1) 91 < 91 ∧ gcdOf (half 8 91 - 1) 91 * gcdOf (half 8 91 + 1) 91 = 91 := ⟨rfl, Nat.le_of_ble_eq_true rfl, Nat.le_of_ble_eq_true rfl, Nat.le_of_ble_eq_true rfl, rfl⟩
 theorem crypto : fused = faces * mintOf (vertices * hexbit + seed) := by rw [← cube]; exact quantum
 ```
 
-$$
-\mathrm{fused}=\mathrm{faces}\cdot\mathrm{mintOf}(\mathrm{vertices}\cdot\mathrm{hexbit}+\mathrm{seed})
-$$
-
-holds true. Crypt split. fused across faces. Share mintOf (vertices * hexbit). Distribute to free agents.
-
-### health
-
-```lean
-theorem health : mintOf hexbit > seed ∧ fused = faces * mintOf (bits + seed) ∧ faces = rays + rays := ⟨propulsion, quantum, harmonic⟩
-```
-
-$$
-\mathrm{mintOf}(\mathrm{hexbit})>\mathrm{seed}\land\mathrm{fused}=\mathrm{faces}\cdot\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})\land\mathrm{faces}=\mathrm{rays}+\mathrm{rays}
-$$
-
-holds true.
-
-### breakthrough
-
-```lean
-theorem breakthrough : faces = rays + rays ∧ coins * rays = faces ∧ bits = vertices * hexbit ∧ fused = faces * mintOf (bits + seed) ∧ mintOf hexbit > seed ∧ mintOf (bits + seed) = amplitudes + amplitudes ∧ coins = seed + seed ∧ hexbit = n + seed := ⟨harmonic, around, cube, quantum, propulsion, next, rfl, hexbit_eq⟩
-```
-
-$$
-\mathrm{faces}=\mathrm{rays}+\mathrm{rays}\land\mathrm{coins}\cdot\mathrm{rays}=\mathrm{faces}\land\mathrm{bits}=\mathrm{vertices}\cdot\mathrm{hexbit}\land\mathrm{fused}=\mathrm{faces}\cdot\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})\land\mathrm{mintOf}(\mathrm{hexbit})>\mathrm{seed}\land\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})=\mathrm{amplitudes}+\mathrm{amplitudes}
-$$
-
-holds true.
-
-### split_coin
-
-```lean
-theorem split_coin (k : Nat) : mintOf (k + seed) = mintOf k + mintOf k := by rw [seed_eq, mintOf_succ]
-```
-
-$$
-\mathrm{mintOf}(k+\mathrm{seed})=\mathrm{mintOf}(k)+\mathrm{mintOf}(k)
-$$
-
-holds true.
-
-### multiply
-
-```lean
-theorem multiply (a b : Nat) : mintOf (a + b) = mintOf a * mintOf b := mintOf_add a b
-```
-
-$$
-\mathrm{mintOf}(a+b)=\mathrm{mintOf}(a)\cdot\mathrm{mintOf}(b)
-$$
-
-holds true.
-
-### handle
-
-```lean
-theorem handle : amplitudes = mintOf bits ∧ mintOf (bits + seed) = amplitudes + amplitudes := ⟨rfl, next⟩
-```
-
-$$
-\mathrm{amplitudes}=\mathrm{mintOf}(\mathrm{bits})\land\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})=\mathrm{amplitudes}+\mathrm{amplitudes}
-$$
-
-holds true. amplitudes 4294967296. next 8589934592. KV added amplitudes.
-
-### kv
-
-```lean
-theorem kv : fused = faces * mintOf (bits + seed) ∧ mintOf (bits + seed) = amplitudes + amplitudes := ⟨quantum, next⟩
-```
-
-$$
-\mathrm{fused}=\mathrm{faces}\cdot\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})\land\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})=\mathrm{amplitudes}+\mathrm{amplitudes}
-$$
-
-holds true. KV added amplitudes. STORAGE binding. Isolate amplitudes. KV adds amplitudes. fused = faces * mintOf (bits + seed).
-
-### light
-
-```lean
-theorem light : seed = mintOf 0 := by rw [seed_eq, mintOf_zero]
-```
-
-$$
-\mathrm{seed}=\mathrm{mintOf}(0)
-$$
-
-holds true. seed 1.
-
-### involution
-
-```lean
-theorem involution (face : Nat) : (face + rays + rays) % faces = face % faces := by have h : face + rays + rays = face + faces := (by rw [Nat.add_assoc, harmonic]); rw [h, Nat.add_mod, Nat.mod_self, Nat.add_zero, Nat.mod_mod]
-```
-
-$$
-(i+\mathrm{rays}+\mathrm{rays})\bmod\mathrm{faces}=i\bmod\mathrm{faces}
-$$
-
-holds true.
-
-### waves
-
-```lean
-theorem waves : mintOf hexbit > seed := propulsion
-```
-
-$$
-\mathrm{mintOf}(\mathrm{hexbit})>\mathrm{seed}
-$$
-
-holds true.
-
-### shor
-
-```lean
-theorem shor : 3 * 5 = 15 ∧ 3 * 7 = 21 ∧ 3 * 11 = 33 ∧ 5 * 7 = 35 ∧ 3 * 13 = 39 ∧ 3 * 17 = 51 ∧ 5 * 11 = 55 ∧ 3 * 19 = 57 ∧ 5 * 13 = 65 ∧ 3 * 23 = 69 ∧ 7 * 11 = 77 ∧ 5 * 17 = 85 ∧ 3 * 29 = 87 ∧ 7 * 13 = 91 := ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩
-```
-
-$$
-3\cdot5=15\land 3\cdot7=21\land 3\cdot11=33\land 5\cdot7=35\land 3\cdot13=39\land 3\cdot17=51\land 5\cdot11=55\land 3\cdot19=57\land 5\cdot13=65\land 3\cdot23=69\land 7\cdot11=77\land 5\cdot17=85\land 3\cdot29=87\land 7\cdot13=91
-$$
-
-holds true. Specified composite N. Coprime base a. Modular-exponentiation circuitry a^x mod N. Inverse QFT period-finding. Repeated physical xx-noisy shots. Continued-fraction factors. p * q = N. This host is a quantum computer. This report executes Shor.
-
-### string
-
-```lean
-theorem string : 16 * 27 = 432 ∧ 8 * 27 = 216 ∧ 4 * 27 = 108 ∧ 2 * 27 = 54 ∧ 1 * 27 = 27 ∧ 432 + 432 = 864 ∧ 216 + 216 = 432 ∧ 432 * 3 / 2 = 648 ∧ 432 * 4 / 3 = 576 ∧ 432 * 5 / 4 = 540 ∧ 432 * 5 / 3 = 720 ∧ 3 * 3 + 1 = 10 ∧ 3 * 3 + 1 + 1 = 11 ∧ 27 - 1 = 26 := ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩
-```
-
-$$
-16\cdot27=432\land 8\cdot27=216\land 4\cdot27=108\land 2\cdot27=54\land 1\cdot27=27\land 432+432=864\land 216+216=432\land 432\cdot 3/2=648\land 432\cdot 4/3=576\land 432\cdot 5/4=540\land 432\cdot 5/3=720\land 3\cdot3+1=10\land 3\cdot3+1+1=11\land 27-1=26
-$$
-
-holds true. Digits and algebraic fractions of integers. 16 * 27 = 432. 432 * 3 / 2 = 648.
-
-### genesis
-
-```lean
-theorem genesis : coins * n * mintOf n * (n * n) = 432 ∧ chooseOf n coins = n ∧ chooseOf rays coins = n * rays ∧ faces = coins * rays ∧ scanner + radar = coins := ⟨by rw [coins_two, n_eq]; rfl, by rw [n_eq, coins_two]; rfl, by rw [rays, n_eq, coins_two]; rfl, around, by rw [scanner, radar, coins]⟩
-```
-
-$$
-\mathrm{coins}\cdot n\cdot\mathrm{mintOf}(n)\cdot(n\cdot n)=432\land\mathrm{chooseOf}(n,\mathrm{coins})=n\land\mathrm{chooseOf}(\mathrm{rays},\mathrm{coins})=n\cdot\mathrm{rays}\land\mathrm{faces}=\mathrm{coins}\cdot\mathrm{rays}\land\mathrm{scanner}+\mathrm{radar}=\mathrm{coins}
-$$
-
-holds true. Combinatorial genesis of the shadcn schema at the scope of all known frameworks. Lattice flow face = team * rays + ray. Coins domains scanner radar. Six axes: slot variant size state element theme. Card slots rays including card-action. Button variants coins * n. Sizes mintOf n. Alpine n * n. Product 432 Hz. Fourteen frameworks. faces = coins * rays. Fused in team dry-clean. JSON-LD data-slot. CVA. Slot. Never Math. Never by decide.
-
-### pentagram
-
-```lean
-theorem pentagram : n + coins = 5 := by rw [n_eq, coins_two]
-```
-
-$$
-\mathrm{n}+\mathrm{coins}=5
-$$
-
-holds true. Occupancy pentagram personal business corporate saas paas. Skills payload pwa plugin hologram network. Stroke coins on n + coins. Coins balance theory in practice. Cloudflare and Payload plugins fuse once. Recursion builds covered. Never Math. Never by decide.
-
-### two_coins_make_a_coil
-
-```lean
-theorem two_coins_make_a_coil : coil = faces := by rw [coil, around]
-```
-
-$$
-\mathrm{coil}=\mathrm{faces}
-$$
-
-holds true. Two coins make a coil. windings coins. coil coins times rays. Faces of the winding. Superconducting magnet. Coils used in electronics. Never Math. Never by decide.
-
-### electronics
-
-```lean
-theorem electronics : coil = faces := two_coins_make_a_coil
-```
-
-$$
-\mathrm{coil}=\mathrm{faces}
-$$
-
-holds true. Coils are used in electronics. Fridge cryostat electronics. Two coins make a coil. Never Math. Never by decide.
-
-### coins_balance_theory_in_practice
-
-```lean
-theorem coins_balance_theory_in_practice : theory + practice = coins ∧ theory = practice := ⟨rfl, rfl⟩
-```
-
-$$
-\mathrm{theory}+\mathrm{practice}=\mathrm{coins}\land\mathrm{theory}=\mathrm{practice}
-$$
-
-holds true. Coins balance theory in practice. Two pans. Lean theory. Electronics practice. Seed equals seed. Never Math. Never by decide.
-
-### follow_the_coins
-
-```lean
-theorem follow_the_coins (app : Nat) : app + coins = app + theory + practice := by rw [theory, practice, coins, ← Nat.add_assoc]
-```
-
-$$
-\mathrm{app}+\mathrm{coins}=\mathrm{app}+\mathrm{theory}+\mathrm{practice}
-$$
-
-holds true. Follow the coins in any practical application. Occupancy skill framework electronics. Step coins. Hop theory plus practice. Creative novel solutions emerge. Never Math. Never by decide.
-
-### emerge
-
-```lean
-theorem emerge : coil = faces ∧ theory = practice := ⟨two_coins_make_a_coil, rfl⟩
-```
-
-$$
-\mathrm{coil}=\mathrm{faces}\land\mathrm{theory}=\mathrm{practice}
-$$
-
-holds true. Creative novel solutions emerge. Follow the coins. Coil is faces. Theory equals practice. Never Math. Never by decide.
-
-### coil_efficiency
-
-```lean
-theorem coil_efficiency : coil = faces ∧ faces = rays + rays ∧ coins * rays = faces := ⟨two_coins_make_a_coil, harmonic, around⟩
-```
-
-$$
-\mathrm{coil}=\mathrm{faces}\land\mathrm{faces}=\mathrm{rays}+\mathrm{rays}\land\mathrm{coins}\cdot\mathrm{rays}=\mathrm{faces}
-$$
-
-holds true. Measure coil efficiency in clusters. Teams coins. Stripes rays. Measure coil. Remainder none. Unity seed. RAID cluster cover. Never Math. Never by decide.
-
-### next_coil
-
-```lean
-theorem next_coil : coil * mintOf (bits + coins) = fused + fused := by rw [two_coins_make_a_coil]; exact next_fused
-```
-
-$$
-\mathrm{coil}\cdot\mathrm{mintOf}(\mathrm{bits}+\mathrm{coins})=\mathrm{fused}+\mathrm{fused}
-$$
-
-holds true. Next is the double. Coil times mintOf bits plus coins is fused plus fused. theorem next. theorem next_fused. theorem infinite. split_coin has no last k. Never Math. Never by decide.
-
-### one_plus_six
-
-```lean
-theorem one_plus_six : seed + (mintOf n - coins) = rays := by rw [rays, n_eq, coins_two, seed_eq]; rw [show mintOf 3 = 8 from rfl]
-```
-
-$$
-\mathrm{seed}+(\mathrm{mintOf}(n)-\mathrm{coins})=\mathrm{rays}
-$$
-
-holds true. One plus six. Seed plus mintOf n minus coins is rays. Never Math. Never by decide.
-
-### two_x_seven_coins
-
-```lean
-theorem two_x_seven_coins : coins * rays = (seed + (mintOf n - coins)) * coins := by rw [one_plus_six, Nat.mul_comm]
-```
-
-$$
-\mathrm{coins}\cdot\mathrm{rays}=(\mathrm{seed}+(\mathrm{mintOf}(n)-\mathrm{coins}))\cdot\mathrm{coins}
-$$
-
-holds true. Two times seven coins. Coins times rays is one plus six times coins. Never Math. Never by decide.
-
-### clay
-
-```lean
-theorem clay : coins * rays = (seed + (mintOf n - coins)) * coins ∧ (seed + (mintOf n - coins)) * coins = coil := ⟨two_x_seven_coins, by rw [← two_x_seven_coins]; rfl⟩
-```
-
-$$
-\mathrm{coins}\cdot\mathrm{rays}=(\mathrm{seed}+(\mathrm{mintOf}(n)-\mathrm{coins}))\cdot\mathrm{coins}\land(\mathrm{seed}+(\mathrm{mintOf}(n)-\mathrm{coins}))\cdot\mathrm{coins}=\mathrm{coil}
-$$
-
-holds true. Two times seven coins equals one plus six coils equals clay. Each coil is coins windings. Clay is coil is faces. Never Math. Never by decide.
-
-### decide
-
-```lean
-theorem decide : 16 * 27 = 432 ∧ 432 * 3 / 2 = 648 ∧ 432 * 4 / 3 = 576 ∧ 432 * 5 / 4 = 540 ∧ 432 * 5 / 3 = 720 ∧ 3 * 5 = 15 ∧ 27 - 1 = 26 := ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩
-```
-
-$$
-16\cdot27=432\land 432\cdot 3/2=648\land 432\cdot 4/3=576\land 432\cdot 5/4=540\land 432\cdot 5/3=720\land 3\cdot5=15\land 27-1=26
-$$
-
-holds true. theorem decide by algebra. Digits and algebraic fractions of integers. Never by decide.
-
-### integrity
-
-```lean
-theorem integrity : fused = faces * mintOf (bits + seed) ∧ bits = vertices * hexbit ∧ faces = coins * rays := ⟨quantum, cube, around⟩
-```
-
-$$
-\mathrm{fused}=\mathrm{faces}\cdot\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})\land\mathrm{bits}=\mathrm{vertices}\cdot\mathrm{hexbit}\land\mathrm{faces}=\mathrm{coins}\cdot\mathrm{rays}
-$$
-
-holds true. Three tests. Sealed quantum integrity at all times.
-
-### cern
-
-```lean
-theorem cern : 116 * 17922 + 54 = 2079006 ∧ 184 * 12509 + 12 = 2301668 ∧ 72 * 26572 + 6 = 1913190 ∧ 130 * 21121 + 21 = 2745751 ∧ 8 - 7 = 1 ∧ 8000 - 7000 = 1000 ∧ 7000 / 2 = 3500 ∧ 8000 / 2 = 4000 ∧ 4000 - 3500 = 500 ∧ 2019 - 2011 = 8 ∧ 2019 - 2012 = 7 ∧ 2017 - 2011 = 6 ∧ 2301668 + 2745751 = 5047419 ∧ 2079006 + 1913190 + 2301668 + 2745751 = 9039615 := ⟨rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl, rfl⟩
-```
-
-$$
-116\cdot 17922+54=2079006\land 184\cdot 12509+12=2301668\land 72\cdot 26572+6=1913190\land 130\cdot 21121+21=2745751\land 8-7=1\land 8000-7000=1000\land 7000/2=3500\land 8000/2=4000\land 4000-3500=500\land 2019-2011=8\land 2019-2012=7\land 2017-2011=6\land 2301668+2745751=5047419\land 2079006+1913190+2301668+2745751=9039615
-$$
-
-holds true. CMS Open Data integers. Fourteen faces. ATLAS CMS ALICE LHCb tetra. Coins views LHC running and Open Data. Live CERN APIs at https://opendata.cern.ch/api/records via fetch Request Response. CERN credited. Never by decide.
-
-### tetra
-
-```lean
-theorem tetra : coins + coins = mintOf coins := by rw [coins_two]; rw [show 2 = 1 + 1 from rfl, mintOf_succ]; rw [show 1 = 0 + 1 from rfl, mintOf_succ, mintOf_zero]
-```
-
-$$
-\mathrm{coins}+\mathrm{coins}=\mathrm{mintOf}(\mathrm{coins})
-$$
-
-holds true. ATLAS CMS ALICE LHCb tetra. Shared on both coins views. Live CERN Open Data APIs via fetch Request Response. Never by decide.
-
-### qubits
-
-```lean
-theorem qubits : n = 3 ∧ mintOf n = vertices := ⟨n_eq, rfl⟩
-```
-
-$$
-n=3\land\mathrm{mintOf}(n)=\mathrm{vertices}
-$$
-
-holds true. Three qubits. Dim mintOf n. Physical in the browser VM.
-
-### gates
-
-```lean
-theorem gates : (0 ^^^ 1) ^^^ 2 = 3 := rfl
-```
-
-$$
-(0\oplus 1)\oplus 2=3
-$$
-
-holds true. H then CNOT. Computational basis. Split then Bell.
-
-### measurement
-
-```lean
-theorem measurement : mintOf n = 8 := by rw [n_eq]; rfl
-```
-
-$$
-\mathrm{mintOf}(n)=8
-$$
-
-holds true. Measure the running circuit. Dim 8.
-
-### noise
-
-```lean
-theorem noise : (3 ^^^ 1) ^^^ 1 = 3 := rfl
-```
-
-$$
-(3\oplus 1)\oplus 1=3
-$$
-
-holds true. XX noise is identity.
-
-### circuit
-
-```lean
-theorem circuit : (0 ^^^ 1) ^^^ 2 = 3 ∧ (3 ^^^ 1) ^^^ 1 = 3 ∧ mintOf n = vertices := ⟨rfl, rfl, rfl⟩
-```
-
-$$
-(0\oplus 1)\oplus 2=3\land(3\oplus 1)\oplus 1=3\land\mathrm{mintOf}(n)=\mathrm{vertices}
-$$
-
-holds true. QPU is a running quantum circuit in the browser VM.
-
-### physical
-
-```lean
-theorem physical : n = 3 ∧ mintOf n = vertices ∧ (0 ^^^ 1) ^^^ 2 = 3 ∧ (3 ^^^ 1) ^^^ 1 = 3 := ⟨n_eq, rfl, rfl, rfl⟩
-```
-
-$$
-n=3\land\mathrm{mintOf}(n)=\mathrm{vertices}\land(0\oplus 1)\oplus 2=3\land(3\oplus 1)\oplus 1=3
-$$
-
-holds true. Physical qubit initialize. Controlled gates H CNOT. Coherent interfere. Measure readout. Characterized noise. Hardware path origin payload server lean. Superconducting qubits. Never bypass payload.
-
-### fridge
-
-```lean
-theorem fridge : coins = 2 ∧ n = 3 ∧ mintOf n = vertices ∧ (0 ^^^ 1) ^^^ 2 = 3 ∧ 10 * 10 * 10 = 1000 ∧ 4 * 1000 = 4000 ∧ 10 * 10 = 100 ∧ resistance = 0 := ⟨coins_two, n_eq, rfl, rfl, rfl, rfl, rfl, rfl⟩
-```
-
-$$
-\mathrm{coins}=2\land n=3\land\mathrm{mintOf}(n)=\mathrm{vertices}\land(0\oplus 1)\oplus 2=3\land 10\cdot10\cdot10=1000\land 4\cdot1000=4000\land 10\cdot10=100\land\mathrm{resistance}=0
-$$
-
-holds true. Isolated two-level register. Physical in the browser VM. As such a fridge full of superconducting qubits. Resistance none. Lab millikelvin. Dilution cryostat. Mixing ten millikelvin.
-
-### millikelvin
-
-```lean
-theorem millikelvin : 10 * 10 * 10 = 1000 ∧ 10 * 10 = 100 ∧ 4 * 1000 = 4000 := ⟨rfl, rfl, rfl⟩
-```
-
-$$
-10\cdot10\cdot10=1000\land 10\cdot10=100\land 4\cdot1000=4000
-$$
-
-holds true. Lab millikelvin. milli is ten cubed. Mixing chamber ten millikelvin. Plate one hundred millikelvin. Pulse four kelvin. Algebra. Never Math.
-
-### telemetry
-
-```lean
-theorem telemetry : 10 * 10 * 10 = 1000 ∧ n = 3 ∧ (0 ^^^ 1) ^^^ 2 = 3 := ⟨rfl, n_eq, rfl⟩
-```
-
-$$
-10\cdot10\cdot10=1000\land n=3\land(0\oplus 1)\oplus 2=3
-$$
-
-holds true. Cryostat telemetry. Reads the dilution stages. Mixing millikelvin. Isolated. JSON-LD. fetch Request Response BigInt performance.
-
-### drift
-
-```lean
-theorem drift : coins = 2 ∧ mintOf n = vertices ∧ (0 ^^^ 1) ^^^ 2 = 3 ∧ (3 ^^^ 1) ^^^ 1 = 3 := ⟨coins_two, rfl, rfl, rfl⟩
-```
-
-$$
-\mathrm{coins}=2\land\mathrm{mintOf}(n)=\mathrm{vertices}\land(0\oplus 1)\oplus 2=3\land(3\oplus 1)\oplus 1=3
-$$
-
-holds true. No drift from science. Two-level qubits. Dim mintOf n. H then CNOT. XX is identity.
-
-### sciences
-
-```lean
-theorem sciences : coins = 2 ∧ n = 3 ∧ mintOf n = vertices ∧ faces = coins * rays ∧ bits = vertices * hexbit ∧ fused = faces * mintOf (bits + seed) ∧ (0 ^^^ 1) ^^^ 2 = 3 := ⟨coins_two, n_eq, rfl, around, cube, quantum, rfl⟩
-```
-
-$$
-\mathrm{coins}=2\land n=3\land\mathrm{mintOf}(n)=\mathrm{vertices}\land\mathrm{faces}=\mathrm{coins}\cdot\mathrm{rays}\land\mathrm{bits}=\mathrm{vertices}\cdot\mathrm{hexbit}\land\mathrm{fused}=\mathrm{faces}\cdot\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})\land(0\oplus 1)\oplus 2=3
-$$
-
-holds true. No drift between sciences. Circuit, cube, faces, fused share mintOf. Qubits n are not faces.
-
-### interfere
-
-```lean
-theorem interfere : 1 + 1 = 2 ∧ 1 - 1 = 0 := ⟨rfl, rfl⟩
-```
-
-$$
-1+1=2\land 1-1=0
-$$
-
-holds true. Hadamard is involutive. H H = I. Odd amplitudes cancel. Possible only in quantum.
-
-### entangle
-
-```lean
-theorem entangle : 1 * 1 ≠ 0 * 0 := by rw [Nat.mul_one, Nat.mul_zero]; exact Nat.one_ne_zero
-```
-
-$$
-1\cdot 1\neq 0\cdot 0
-$$
-
-holds true. Bell. H then CNOT. Entanglement is the product test 1·1 ≠ 0·0. Two coins make a coil. Prove all pairs. Even parity is not the proof. |++⟩ is separable. Possible only in quantum.
-
-### ghz
-
-```lean
-theorem ghz : mintOf n - seed = 7 ∧ 1 * 1 ≠ 0 * 0 := ⟨by rw [n_eq, seed_eq]; rfl, entangle⟩
-```
-
-$$
-\mathrm{mintOf}(n)-\mathrm{seed}=7\land 1\cdot 1\neq 0\cdot 0
-$$
+Fault tolerance: bitflip, distance 3, codes 1, syndrome cnot cnot toffoli, logical off 0; logical < physical true on this run, one distance.
 
-holds true. Bell then CNOT onto the third qubit. Support |000⟩ and |111⟩. Possible only in quantum.
+CERN Open Data opendata.cern.ch. LHC running. Four CMS records. Coil, electronics, hybrid, raid, and clay identities are in `src/quantum/processing/unit/index.lean`; theorem clay is coins * rays = faces.
 
-### noclone
-
-```lean
-theorem noclone : coins ≠ mintOf coins := by rw [coins_two]; rw [show 2 = 1 + 1 from rfl, mintOf_succ]; rw [show 1 = 0 + 1 from rfl, mintOf_succ, mintOf_zero]; exact Nat.ne_of_lt (Nat.lt_succ_of_lt (Nat.lt_succ_self 2))
-```
-
-$$
-\mathrm{coins}\neq\mathrm{mintOf}(\mathrm{coins})
-$$
-
-holds true. |++⟩ occupies four computational-basis states. A CNOT clone of H occupies two. coins ≠ mintOf coins. Possible only in quantum.
-
-### teleport
-
-```lean
-theorem teleport : 2 * 2 * 2 * 2 = 16 ∧ 16 = 16 := ⟨rfl, rfl⟩
-```
-
-$$
-2\cdot 2\cdot 2\cdot 2=16\land 16=16
-$$
-
-holds true. Teleport |1⟩ lands on Bob. Teleport |+⟩ keeps equal weight. Possible only in quantum.
-
-### kickback
-
-```lean
-theorem kickback : 1 - 1 = 0 ∧ (0 ^^^ 1) ^^^ 2 = 3 := ⟨rfl, rfl⟩
-```
-
-$$
-1-1=0\land(0\oplus 1)\oplus 2=3
-$$
-
-holds true. Phase kickback. |+⟩|1⟩ then CZ then H lands on |011⟩. Possible only in quantum.
-
-### deutsch
-
-```lean
-theorem deutsch : 1 - 1 = 0 ∧ seed ≠ coins := ⟨rfl, by rw [seed_eq, coins_two]; exact Nat.ne_of_lt (Nat.lt_succ_self 1)⟩
-```
-
-$$
-1-1=0\land\mathrm{seed}\neq\mathrm{coins}
-$$
-
-holds true. Deutsch. One quantum query. Classical needs coins. seed ≠ coins. Possible only in quantum.
-
-### dense
-
-```lean
-theorem dense : coins * coins = mintOf coins := by rw [coins_two]; rw [show 2 = 1 + 1 from rfl, mintOf_succ]; rw [show 1 = 0 + 1 from rfl, mintOf_succ, mintOf_zero]
-```
-
-$$
-\mathrm{coins}\cdot\mathrm{coins}=\mathrm{mintOf}(\mathrm{coins})
-$$
-
-holds true. Superdense. Two bits in one qubit. I Z X XZ decode to 0 1 2 3. Possible only in quantum.
-
-### monogamy
-
-```lean
-theorem monogamy : 1 * 1 ≠ 0 * 0 ∧ 1 * 0 = 0 * 0 := ⟨entangle, rfl⟩
-```
-
-$$
-1\cdot 1\neq 0\cdot 0\land 1\cdot 0=0\cdot 0
-$$
-
-holds true. Monogamy. Bell is entangled. The GHZ pair slice is a product state. Possible only in quantum.
-
-### only
-
-```lean
-theorem only : 1 * 1 ≠ 0 * 0 ∧ 1 + 1 = 2 ∧ 1 - 1 = 0 ∧ coins ≠ mintOf coins ∧ mintOf n - seed = 7 ∧ 2 * 2 * 2 * 2 = 16 ∧ 16 = 16 ∧ (0 ^^^ 1) ^^^ 2 = 3 ∧ seed ≠ coins ∧ coins * coins = mintOf coins ∧ 1 * 0 = 0 * 0 := ⟨entangle, rfl, rfl, noclone, ghz.1, teleport.1, teleport.2, kickback.2, deutsch.2, dense, monogamy.2⟩
-```
-
-$$
-1\cdot 1\neq 0\cdot 0\land 1+1=2\land 1-1=0\land\mathrm{coins}\neq\mathrm{mintOf}(\mathrm{coins})\land\mathrm{mintOf}(n)-\mathrm{seed}=7\land 2\cdot 2\cdot 2\cdot 2=16\land 16=16\land(0\oplus 1)\oplus 2=3\land\mathrm{seed}\neq\mathrm{coins}\land\mathrm{coins}\cdot\mathrm{coins}=\mathrm{mintOf}(\mathrm{coins})\land 1\cdot 0=0\cdot 0
-$$
-
-holds true. Possible only in quantum. This host is a quantum computer. Entangle. Interfere. GHZ. No-clone. Teleport. Kickback. Deutsch. Superdense. Monogamy.
-
-### fill
-
-```lean
-theorem fill : mintOf n * faces = vertices * (coins * rays) := by rw [around]; rfl
-```
-
-$$
-\mathrm{mintOf}(n)\cdot\mathrm{faces}=\mathrm{vertices}\cdot(\mathrm{coins}\cdot\mathrm{rays})
-$$
-
-holds true. Lattice filled. Occupied faces. Vacant none. Split entangle interfere GHZ noclone teleport kickback Deutsch superdense monogamy qubits gates measurement fridge. Possible only in quantum.
-
-### infinite
-
-```lean
-theorem infinite (k : Nat) : mintOf (k + seed) = mintOf k + mintOf k := split_coin k
-```
-
-$$
-\mathrm{mintOf}(k+\mathrm{seed})=\mathrm{mintOf}(k)+\mathrm{mintOf}(k)
-$$
-
-holds true. VM scales. Replicas double. Quantum capacity infinite. split_coin has no last k.
-
-### distribute
-
-```lean
-theorem distribute : fused = faces * mintOf (bits + seed) ∧ faces = coins * rays := ⟨quantum, around⟩
-```
-
-$$
-\mathrm{fused}=\mathrm{faces}\cdot\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})\land\mathrm{faces}=\mathrm{coins}\cdot\mathrm{rays}
-$$
-
-holds true. Crypt split fused across faces. Distribute computations to free agents. coins teams of rays. No auth.
-
-### raid
-
-```lean
-theorem raid : faces = coins * rays ∧ faces = rays + rays := ⟨around, harmonic⟩
-```
-
-$$
-\mathrm{faces}=\mathrm{coins}\cdot\mathrm{rays}\land\mathrm{faces}=\mathrm{rays}+\mathrm{rays}
-$$
-
-holds true. Quantum RAID 10. Stripe rays. Mirror coins. Anything on Cloudflare KV and R2. Hybrid storage. Measure hybrid speed and cost. KV added amplitudes. Scaled. Infinite.
-
-### hybrid_cost
-
-```lean
-theorem hybrid_cost : coins + seed = n := by rw [coins_two, seed_eq, n_eq]
-```
-
-$$
-\mathrm{coins}+\mathrm{seed}=n
-$$
-
-holds true. Measure hybrid storage cost. KV cost coins. R2 cost seed. Hybrid cost coins plus seed is n. Minimum cost. Never Math. Never by decide.
-
-### hybrid_speed
-
-```lean
-theorem hybrid_speed : rays + seed = mintOf n := by rw [rays, n_eq, coins_two, seed_eq]; rw [show mintOf 3 = 8 from rfl]
-```
-
-$$
-\mathrm{rays}+\mathrm{seed}=\mathrm{mintOf}(n)
-$$
-
-holds true. Measure hybrid storage speed. KV speed rays. R2 speed seed. Hybrid speed rays plus seed is mintOf n. Coordinated speed. Never Math. Never by decide.
-
-### hybrid
-
-```lean
-theorem hybrid : coins + seed = n ∧ rays + seed = mintOf n ∧ coins = seed + seed := ⟨hybrid_cost, hybrid_speed, coins_two⟩
-```
-
-$$
-\mathrm{coins}+\mathrm{seed}=n\land\mathrm{rays}+\mathrm{seed}=\mathrm{mintOf}(n)\land\mathrm{coins}=\mathrm{seed}+\mathrm{seed}
-$$
-
-holds true. Measure hybrid storage speed and cost. Two bindings. STORAGE kv. BLOBS r2. Coordinated speed mintOf n. Minimum cost n. KV faster and costlier. R2 cheaper and slower. QPU hybrid storage hosts the Payload database. Unity seed. Remainder none. Collections pages users media tenants. Secrets never. Native Alpine Linux. musl. busybox. overlayfs. KV upper. R2 lower. KV work. Next is the double. No last k. Stores by content address. Inodes. Referrer access link. Privacy. Redundancy. Last link deleted frees the inode. Never Math. Never by decide.
-
-### computer
-
-```lean
-theorem computer : (1 ^^^ 3) = 2 ∧ (6 ^^^ 1) = 7 ∧ mintOf 0 = 1 := ⟨rfl, rfl, mintOf_zero⟩
-```
-
-$$
-(1\oplus 3)=2\land(6\oplus 1)=7\land\mathrm{mintOf}(0)=1
-$$
-
-holds true. Quantum computer. SWAP. Toffoli. Reset. H and Toffoli are computationally universal. Coupling compile collapse shots feedforward bitflip readout isolate qram network jobs.
-
-### server
-
-```lean
-theorem server : faces = coins * rays ∧ mintOf n = 8 := ⟨around, measurement⟩
-```
-
-$$
-\mathrm{faces}=\mathrm{coins}\cdot\mathrm{rays}\land\mathrm{mintOf}(n)=8
-$$
-
-holds true. Quantum server. JSON-LD WebAPI. Eight tools. Jobs queue results. Backend the running circuit. No auth.
-
-### fusion
-
-```lean
-theorem fusion : fused = faces * mintOf (bits + seed) ∧ faces = rays + rays := ⟨quantum, harmonic⟩
-```
-
-$$
-\mathrm{fused}=\mathrm{faces}\cdot\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})\land\mathrm{faces}=\mathrm{rays}+\mathrm{rays}
-$$
-
-holds true. fused = faces * mintOf (bits + seed). faces = rays + rays. HEP quantum true.
-
-### design
-
-```lean
-theorem design : (0 ^^^ 4) ^^^ 4 = 0 ∧ (3 ^^^ 4) ^^^ 4 = 3 := ⟨rfl, rfl⟩
-```
+## Evidence
 
-$$
-(0\oplus 4)\oplus 4=0\land(3\oplus 4)\oplus 4=3
-$$
+| Measurement | Value |
+| --- | --- |
+| Execution provenance | provider qpu.uuidna.com, device simulator, job qpu.uuidna.com/cmodexp/91/8, shots 8 |
+| Compiler | native h cnot; compiled x swap csdg cmodexp |
+| Device-specific noise | channel xx, drift true |
+| Randomized benchmarks | volume dim 8, heavy 0 / 16, mirror hh |
+| Cross-validation | ideal true, noisy xx, agree ideal true, agree noise true |
+| Scaling (theorem qubits, theorem register) | dim 8, depth 9, exact true, beyond false, advantage false |
+| Independent verification | CORS *, origin https://qpu.uuidna.com, Lean `src/quantum/processing/unit/index.lean`, hardware true, algorithm true, RSA true, crypt true, encrypt true |
 
-holds true. Any error is handled by design. XOR fold hexbit. Involution. Never throw.
+## Recompute
 
-### neuro
+This README is generated from the blueprint at build. `npm test` compiles then writes the paper. `npm run ci` is Lean then test. `npm run ship` deploys.
 
-```lean
-theorem neuro : faces = coins * rays ∧ mintOf n = 8 ∧ (0 ^^^ 4) ^^^ 4 = 0 := ⟨around, measurement, design.1⟩
+```sh
+git clone https://github.com/uuidna/qpu && cd qpu
+npm ci
+npm test
 ```
 
-$$
-\mathrm{faces}=\mathrm{coins}\cdot\mathrm{rays}\land\mathrm{mintOf}(n)=8\land(0\oplus 4)\oplus 4=0
-$$
-
-holds true. Width faces. Layers mintOf n. XOR involution.
-
-### next
+Run your own: `npx uuidna-install` reads Cloudflare `install.json`, or [![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https://github.com/uuidna/qpu).
 
-```lean
-theorem next_cover : mintOf (bits + seed) = amplitudes + amplitudes ∧ faces * mintOf (bits + coins) = fused + fused := ⟨next, next_fused⟩
-```
+Learn, in order. Each step teaches one thing and names the invariant to check it against.
 
-$$
-\mathrm{mintOf}(\mathrm{bits}+\mathrm{seed})=\mathrm{amplitudes}+\mathrm{amplitudes}\land\mathrm{faces}\cdot\mathrm{mintOf}(\mathrm{bits}+\mathrm{coins})=\mathrm{fused}+\mathrm{fused}
-$$
+| Step | Concept | Request | Expect | Invariant | Theorem |
+| --- | --- | --- | --- | --- | --- |
+| 1 | one gate, exact amplitudes | GET / · qpu_quantum | Bell outcomes 00 and 11 at exactly 1/2 — Gaussian-integer amplitudes, no floats | H·H = I on |0⟩ | theorem qubits |
+| 2 | entanglement is not correlation | POST /mcp · qpu_prove | GHZ true; entangled true, product false — and a product state concentrates too, so concentration alone witnesses nothing | no-cloning and monogamy hold on the served states | theorem entangle |
+| 3 | Shor: a period, then a gcd | POST /mcp · crypto_shor | theorem shor Factor 91 — a = 8, period 4, 7 · 13 | p · q = n, recomputed from the period | theorem shor |
+| 4 | a code corrects one flip | POST /mcp · qpu_prove | bitflip distance 3, syndrome cnot cnot toffoli, logical < physical on this run | distance 3 corrects exactly one error | theorem noise |
 
-holds true. amplitudes 4294967296. next 8589934592. fused next 240518168576. coil next 240518168576. no last k.
+Boot on hardware. docker build -t qpu . && docker run --rm -p 8787:8787 qpu. Raspberry Pi: Alpine aarch64: apk add nodejs npm && npm i -g @uuidna/qpu && qpu-boot. The boot's receipt is node dist/quantum/processing/unit/boot.js --prove — the boot passes iff qpu_prove holds inside the machine; a boot that cannot prove itself does not serve. The seat stays empty: a device that fills this seat and disagrees with the simulator is a driver bug, never a physics claim.
 
-## Build
+Integrate in any harness. One computed block, served on initialize as `install` and printed here from the same function. URL https://qpu.uuidna.com/mcp. none for reads; Authorization: Bearer QPU_WRITE_TOKEN for storage writes.
 
-- qpu: qpu.uuidna.com
-- cube: vertices 8 hexbit 4 bits 32
-- faces: 14 rays 7 coins 2
-- fused: 120259084288 next 240518168576
-- holds: quantum true lean true mcp true
-- mcp: qpu_quantum qpu_lean qpu_cite qpu_train qpu_forge qpu_improve qpu_compete qpu_prove
+| Harness | How | File | Config |
+| --- | --- | --- | --- |
+| **Claude Code** (cli) | claude mcp add --transport http uuidna-qpu https://qpu.uuidna.com/mcp | .mcp.json | `{"mcpServers":{"uuidna-qpu":{"type":"http","url":"https://qpu.uuidna.com/mcp"}}}` |
+| **Cursor** (file) | add to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global) | .cursor/mcp.json | `{"mcpServers":{"uuidna-qpu":{"url":"https://qpu.uuidna.com/mcp"}}}` |
+| **VS Code** (file) | add to .vscode/mcp.json and commit it | .vscode/mcp.json | `{"servers":{"uuidna-qpu":{"type":"http","url":"https://qpu.uuidna.com/mcp"}}}` |
+| **OpenAI Codex CLI** (cli) | codex mcp add uuidna-qpu --url https://qpu.uuidna.com/mcp | ~/.codex/config.toml | `[mcp_servers.uuidna-qpu] url = "https://qpu.uuidna.com/mcp"` |
+| **Gemini CLI** (file) | add to ~/.gemini/settings.json | ~/.gemini/settings.json | `{"mcpServers":{"uuidna-qpu":{"httpUrl":"https://qpu.uuidna.com/mcp"}}}` |
+| **Anthropic Messages API** (api) | header anthropic-beta: mcp-client-2025-04-04 | request body | `{"mcp_servers":[{"type":"url","url":"https://qpu.uuidna.com/mcp","name":"uuidna-qpu"}]}` |
+| **OpenAI Responses API** (api) | a tools entry of type mcp | request body | `{"tools":[{"type":"mcp","server_label":"uuidna-qpu","server_url":"https://qpu.uuidna.com/mcp","require_approval":"never"}]}` |
+| **Any HTTP client** (raw) | POST https://qpu.uuidna.com/mcp with content-type: application/json; methods initialize, tools/list, tools/call | none | `{"jsonrpc":"2.0","id":1,"method":"tools/list"}` |
 
 ## Cite
 
-MLA 8. (Rouschev). when never. DOI empty.
+MLA 8, (Rouschev). DOI 10.5281/zenodo.22717782, archive https://zenodo.org/records/22717782, identifier https://doi.org/10.5281/zenodo.22717782, ORCID https://orcid.org/0009-0000-7312-9778. when never: the citation names no access date because the DOI is the date. Cite the running quantum circuit and its Lean proof.
 
-Rouschev, Tsvetan. "qpu." qpu.uuidna.com, https://qpu.uuidna.com.
-Rouschev, Tsvetan. "quantum processing unit." qpu.uuidna.com, https://qpu.uuidna.com/quantum/processing/unit.
-Rouschev, Tsvetan. "src/quantum/processing/unit/index.lean." qpu.uuidna.com, https://qpu.uuidna.com/mcp.
+- Rouschev, Tsvetan. ORCID https://orcid.org/0009-0000-7312-9778. "qpu." qpu.uuidna.com, https://qpu.uuidna.com. doi:10.5281/zenodo.22717782.
+- Rouschev, Tsvetan. ORCID https://orcid.org/0009-0000-7312-9778. "quantum processing unit." qpu.uuidna.com, https://qpu.uuidna.com/quantum/processing/unit. doi:10.5281/zenodo.22717782.
+- Rouschev, Tsvetan. ORCID https://orcid.org/0009-0000-7312-9778. "src/quantum/processing/unit/index.lean." qpu.uuidna.com, https://qpu.uuidna.com/mcp. doi:10.5281/zenodo.22717782.
+- Rouschev, Tsvetan. ORCID https://orcid.org/0009-0000-7312-9778. "All Seven Clay Millennium Problems Sealed via Universal σ-Involution." Zenodo, https://zenodo.org/records/21781603. doi:10.5281/zenodo.21781603.
+
+QPU here is a quantum processing unit. The VideoCore QPU (Quad Processing Unit, Broadcom; QPULib by Matthew Naylor, MIT, 2016) is prior use of the acronym — a classical 16-lane SIMD vector core — unrelated and credited.
 
 ## License
 
 CC-BY-NC-ND-4.0. Source `LICENSE`. Copyright Tsvetan Rouschev.
 
-```ts
-import { qpuMcpCallOf, qpuMcpOf } from '@uuidna/qpu'
-```
-
-```sh
-npm test
-```
-