@uuidna/qpu 0.1.0 → 0.1.2

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@uuidna/qpu",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "publishConfig": {
     "access": "public"
   },
-  "description": "Running quantum circuit at https://qpu.uuidna.com. theorem quantum. Lean proof. JSON-LD. No auth.",
+  "description": "Running quantum circuit at https://qpu.uuidna.com. theorem quantum. Public quantum API. No auth. JSON-LD. The TypeScript and Lean sources are the blueprint.",
   "type": "module",
   "license": "CC-BY-NC-ND-4.0",
   "funding": {
@@ -14,7 +14,7 @@
   "author": {
     "name": "Tsvetan Rouschev",
     "email": "ceccec@psg.bg",
-    "url": "https://revolut.me/ceccec"
+    "url": "https://orcid.org/0009-0000-7312-9778"
   },
   "homepage": "https://qpu.uuidna.com",
   "repository": {
@@ -31,27 +31,37 @@
     "mcp"
   ],
   "main": "./dist/quantum/processing/unit/index.js",
-  "types": "./dist/quantum/processing/unit/index.d.ts",
+  "types": "./qpu.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/quantum/processing/unit/index.d.ts",
-      "import": "./dist/quantum/processing/unit/index.js"
+      "types": "./qpu.d.ts",
+      "import": "./dist/quantum/processing/unit/index.js",
+      "default": "./dist/quantum/processing/unit/index.js"
+    },
+    "./boot": {
+      "types": "./dist/quantum/processing/unit/boot.d.ts",
+      "import": "./dist/quantum/processing/unit/boot.js",
+      "default": "./dist/quantum/processing/unit/boot.js"
     }
   },
   "files": [
     "dist",
+    "qpu.d.ts",
     "src/quantum/processing/unit/index.lean",
     "LICENSE",
     "README.md",
     "CITATION.cff",
     "mcp.json",
     "install.json",
-    "worker.js",
-    "wrangler.toml",
     "!dist/**/*.test.js",
     "!dist/**/*.test.d.ts",
+    "!dist/**/*.d.ts",
     "!dist/**/readme.js",
-    "!dist/**/readme.d.ts"
+    "!dist/**/readme.d.ts",
+    "!dist/**/receipt.js",
+    "!dist/**/receipt.d.ts",
+    "!dist/**/receipted.js",
+    "!dist/**/receipted.d.ts"
   ],
   "sideEffects": false,
   "engines": {
@@ -60,14 +70,26 @@
   "scripts": {
     "prepare": "tsc -p tsconfig.json",
     "lean": "lean src/quantum/processing/unit/index.lean",
-    "build": "tsc -p tsconfig.json && node dist/quantum/processing/unit/readme.js",
-    "test": "npm run build && node --test dist/quantum/processing/unit/*.test.js",
-    "ci": "npm run lean && npm test",
-    "ship": "npm run build && npx wrangler deploy"
+    "build": "rm -rf dist && tsc -p tsconfig.json && node dist/quantum/processing/unit/readme.js",
+    "test": "npm run build && node --test --test-reporter=./dist/quantum/processing/unit/receipt.js --test-reporter-destination=stdout dist/quantum/processing/unit/*.test.js",
+    "ci": "npm run lean && npm test && npm run proof",
+    "prepublishOnly": "npm run build",
+    "ship": "npm run build && npx wrangler deploy",
+    "test:rollcall": "npm run build && node --test dist/quantum/processing/unit/*.test.js",
+    "lean:embed": "node scripts/embed-lean.mjs",
+    "verify:live": "node scripts/verify-live.mjs https://qpu.uuidna.com",
+    "test:live": "QPU_LIVE=https://qpu.uuidna.com node --test --test-reporter=spec dist/quantum/processing/unit/live.test.js",
+    "proof": "git diff --exit-code -- test-receipt.json",
+    "examine": "node scripts/examine.mjs https://qpu.uuidna.com",
+    "post-push": "node scripts/post-push.mjs",
+    "land": "npm test && git push && node scripts/post-push.mjs --wait && npm run verify:live"
   },
   "devDependencies": {
     "@types/node": "26.5.1",
     "typescript": "7.0.2",
     "wrangler": "4.131.0"
+  },
+  "bin": {
+    "qpu-boot": "./dist/quantum/processing/unit/boot.js"
   }
 }

package/qpu.d.ts

@@ -0,0 +1,12 @@
+/** Public QPU. Constructors live in the JS. Inferred .d.ts is not the npm types. */
+export declare function qpuMcpOf(): {
+  tools: readonly { name: string }[]
+  holds: boolean
+  origin: string
+  href: string
+}
+export declare function qpuMcpCallOf(name: string, args?: Record<string, unknown>): Promise<unknown>
+export declare function qpuQuantumOf(): { holds: boolean; fused: number; next: number }
+export declare function qpuLeanOf(): { holds: boolean; src: string }
+export declare function qpuProveOf(): { holds: boolean }
+export declare function qpuReadmeOf(): string

package/src/quantum/processing/unit/index.lean

@@ -1,5 +1,12 @@
 def mintOf : Nat → Nat | 0 => 1 | k + 1 => mintOf k + mintOf k
 def chooseOf : Nat → Nat → Nat | _, 0 => 1 | 0, _ + 1 => 0 | n + 1, k + 1 => chooseOf n (k + 1) + chooseOf n k
+def powModAux : Nat → Nat → Nat → Nat → Nat | 0, _, _, acc => acc | k + 1, a, m, acc => powModAux k a m (acc * a % m)
+def powMod (a e m : Nat) : Nat := powModAux e a m (1 % m)
+def periodAux : Nat → Nat → Nat → Nat → Nat | 0, _, _, _ => 0 | fuel + 1, a, m, r => if powMod a r m = 1 then r else periodAux fuel a m (r + 1)
+def periodOf (a m : Nat) : Nat := periodAux m a m 1
+def gcdAux : Nat → Nat → Nat → Nat | 0, a, _ => a | fuel + 1, a, b => if b = 0 then a else gcdAux fuel b (a % b)
+def gcdOf (a b : Nat) : Nat := gcdAux (a + b) a b
+def half (a m : Nat) : Nat := powMod a (periodOf a m / 2) m
 def n : Nat := ["quantum", "processing", "unit"].length
 def seed : Nat := mintOf (n - n)
 def coins : Nat := seed + seed
@@ -35,9 +42,7 @@ theorem propulsion : mintOf hexbit > seed := by rw [seed_eq]; exact (mintOf_zero
 theorem crypto : fused = faces * mintOf (vertices * hexbit + seed) := by rw [← cube]; exact quantum
 theorem health : mintOf hexbit > seed ∧ fused = faces * mintOf (bits + seed) ∧ faces = rays + rays := ⟨propulsion, quantum, harmonic⟩
 theorem next : mintOf (bits + seed) = amplitudes + amplitudes := by rw [amplitudes, seed_eq, mintOf_succ]
-theorem next_fused : faces * mintOf (bits + coins) = fused + fused := by
-  rw [fused, coins_two, seed_eq]
-  rw [show bits + 2 = bits + 1 + 1 from rfl, mintOf_succ, Nat.mul_add]
+theorem next_fused : faces * mintOf (bits + coins) = fused + fused := by rw [fused, coins_two, seed_eq]; rw [show bits + 2 = bits + 1 + 1 from rfl, mintOf_succ, Nat.mul_add]
 theorem split_coin (k : Nat) : mintOf (k + seed) = mintOf k + mintOf k := by rw [seed_eq, mintOf_succ]
 theorem multiply (a b : Nat) : mintOf (a + b) = mintOf a * mintOf b := mintOf_add a b
 theorem handle : amplitudes = mintOf bits ∧ mintOf (bits + seed) = amplitudes + amplitudes := ⟨rfl, next⟩
@@ -47,43 +52,29 @@ theorem involution (face : Nat) : (face + rays + rays) % faces = face % faces :=
 theorem waves : mintOf hexbit > seed := propulsion
 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⟩
 theorem next_cover : mintOf (bits + seed) = amplitudes + amplitudes ∧ faces * mintOf (bits + coins) = fused + fused := ⟨next, next_fused⟩
-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⟩
+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 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⟩
 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]⟩
 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⟩
 theorem integrity : fused = faces * mintOf (bits + seed) ∧ bits = vertices * hexbit ∧ faces = coins * rays := ⟨quantum, cube, around⟩
 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⟩
-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]
+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]
 theorem qubits : n = 3 ∧ mintOf n = vertices := ⟨n_eq, rfl⟩
 theorem gates : (0 ^^^ 1) ^^^ 2 = 3 := rfl
 theorem measurement : mintOf n = 8 := by rw [n_eq]; rfl
 theorem noise : (3 ^^^ 1) ^^^ 1 = 3 := rfl
 theorem circuit : (0 ^^^ 1) ^^^ 2 = 3 ∧ (3 ^^^ 1) ^^^ 1 = 3 ∧ mintOf n = vertices := ⟨rfl, rfl, rfl⟩
 theorem physical : n = 3 ∧ mintOf n = vertices ∧ (0 ^^^ 1) ^^^ 2 = 3 ∧ (3 ^^^ 1) ^^^ 1 = 3 := ⟨n_eq, rfl, rfl, rfl⟩
-def resistance : Nat := 0
-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⟩
-theorem millikelvin : 10 * 10 * 10 = 1000 ∧ 10 * 10 = 100 ∧ 4 * 1000 = 4000 := ⟨rfl, rfl, rfl⟩
-theorem telemetry : 10 * 10 * 10 = 1000 ∧ n = 3 ∧ (0 ^^^ 1) ^^^ 2 = 3 := ⟨rfl, n_eq, rfl⟩
 theorem drift : coins = 2 ∧ mintOf n = vertices ∧ (0 ^^^ 1) ^^^ 2 = 3 ∧ (3 ^^^ 1) ^^^ 1 = 3 := ⟨coins_two, rfl, rfl, rfl⟩
 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⟩
 theorem interfere : 1 + 1 = 2 ∧ 1 - 1 = 0 := ⟨rfl, rfl⟩
 theorem entangle : 1 * 1 ≠ 0 * 0 := by rw [Nat.mul_one, Nat.mul_zero]; exact Nat.one_ne_zero
 theorem ghz : mintOf n - seed = 7 ∧ 1 * 1 ≠ 0 * 0 := ⟨by rw [n_eq, seed_eq]; rfl, entangle⟩
-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))
+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))
 theorem teleport : 2 * 2 * 2 * 2 = 16 ∧ 16 = 16 := ⟨rfl, rfl⟩
 theorem kickback : 1 - 1 = 0 ∧ (0 ^^^ 1) ^^^ 2 = 3 := ⟨rfl, rfl⟩
 theorem deutsch : 1 - 1 = 0 ∧ seed ≠ coins := ⟨rfl, by rw [seed_eq, coins_two]; exact Nat.ne_of_lt (Nat.lt_succ_self 1)⟩
-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]
+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]
 theorem monogamy : 1 * 1 ≠ 0 * 0 ∧ 1 * 0 = 0 * 0 := ⟨entangle, rfl⟩
 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⟩
 theorem fill : mintOf n * faces = vertices * (coins * rays) := by rw [around]; rfl
@@ -97,11 +88,8 @@ def kvSpeed : Nat := rays
 def r2Speed : Nat := seed
 def hybridSpeed : Nat := kvSpeed + r2Speed
 theorem hybrid_cost : coins + seed = n := by rw [coins_two, seed_eq, n_eq]
-theorem hybrid_speed : rays + seed = mintOf n := by
-  rw [rays, n_eq, coins_two, seed_eq]
-  rw [show mintOf 3 = 8 from rfl]
-theorem hybrid : coins + seed = n ∧ rays + seed = mintOf n ∧ coins = seed + seed :=
-  ⟨hybrid_cost, hybrid_speed, coins_two⟩
+theorem hybrid_speed : rays + seed = mintOf n := by rw [rays, n_eq, coins_two, seed_eq]; rw [show mintOf 3 = 8 from rfl]
+theorem hybrid : coins + seed = n ∧ rays + seed = mintOf n ∧ coins = seed + seed := ⟨hybrid_cost, hybrid_speed, coins_two⟩
 theorem computer : (1 ^^^ 3) = 2 ∧ (6 ^^^ 1) = 7 ∧ mintOf 0 = 1 := ⟨rfl, rfl, mintOf_zero⟩
 theorem server : faces = coins * rays ∧ mintOf n = 8 := ⟨around, measurement⟩
 theorem pentagram : n + coins = 5 := by rw [n_eq, coins_two]
@@ -111,20 +99,27 @@ def coil : Nat := coins * rays
 theorem two_coins_make_a_coil : coil = faces := by rw [coil, around]
 theorem electronics : coil = faces := two_coins_make_a_coil
 theorem coins_balance_theory_in_practice : theory + practice = coins ∧ theory = practice := ⟨rfl, rfl⟩
-theorem follow_the_coins (app : Nat) : app + coins = app + theory + practice := by
-  rw [theory, practice, coins, ← Nat.add_assoc]
+theorem follow_the_coins (app : Nat) : app + coins = app + theory + practice := by rw [theory, practice, coins, ← Nat.add_assoc]
 theorem emerge : coil = faces ∧ theory = practice := ⟨two_coins_make_a_coil, rfl⟩
 theorem coil_efficiency : coil = faces ∧ faces = rays + rays ∧ coins * rays = faces := ⟨two_coins_make_a_coil, harmonic, around⟩
-theorem next_coil : coil * mintOf (bits + coins) = fused + fused := by
-  rw [two_coins_make_a_coil]
-  exact next_fused
-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]
-theorem two_x_seven_coins : coins * rays = (seed + (mintOf n - coins)) * coins := by
-  rw [one_plus_six, Nat.mul_comm]
-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⟩
+theorem next_coil : coil * mintOf (bits + coins) = fused + fused := by rw [two_coins_make_a_coil]; exact next_fused
+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]
+theorem two_x_seven_coins : coins * rays = (seed + (mintOf n - coins)) * coins := by rw [one_plus_six, Nat.mul_comm]
+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⟩
 theorem fusion : fused = faces * mintOf (bits + seed) ∧ faces = rays + rays := ⟨quantum, harmonic⟩
 theorem design : (0 ^^^ 4) ^^^ 4 = 0 ∧ (3 ^^^ 4) ^^^ 4 = 3 := ⟨rfl, rfl⟩
 theorem neuro : faces = coins * rays ∧ mintOf n = 8 ∧ (0 ^^^ 4) ^^^ 4 = 0 := ⟨around, measurement, design.1⟩
+def planck : Nat := 662607015
+def boltzmann : Nat := 1380649
+def transmon : Nat := 5
+def photon : Nat := planck * transmon
+def thermal (millikelvin : Nat) : Nat := boltzmann * millikelvin * 10
+theorem temperature : photon / thermal 10 = 23 ∧ photon / thermal 100 = 2 ∧ photon / thermal 4000 = 0 ∧ 4000 / 100 = 40 ∧ 100 / 10 = 10 ∧ 10 < 35 := ⟨rfl, rfl, rfl, rfl, rfl, Nat.le_of_ble_eq_true rfl⟩
+def bcs : Nat := 352
+def aluminium : Nat := 1200
+def niobium : Nat := 9200
+def gap (tc : Nat) : Nat := bcs * boltzmann * tc / planck / 10
+theorem superconductivity : aluminium > 10 ∧ niobium > aluminium ∧ bcs / 100 = 3 ∧ gap aluminium = 88 ∧ gap aluminium > transmon ∧ gap niobium = 674 := ⟨Nat.le_of_ble_eq_true rfl, Nat.le_of_ble_eq_true rfl, rfl, rfl, Nat.le_of_ble_eq_true rfl, rfl⟩
+/-- PLANES FOLD: one plane holds n qubits as 4n numbers, a product state by construction; at n = rays that is fewer than the mintOf (rays + seed) an entangled register needs, so entanglement is held by the fold of the coins' planes, never by one. -/
+def plane : Nat := coins * coins * rays
+theorem planes : plane < mintOf (rays + seed) ∧ coins * rays = faces := ⟨Nat.le_of_ble_eq_true rfl, around⟩