Textbooks
qpu seals each textbook example as an integer theorem whose docstring is its human sentence (Qpu/Textbook.lean). Each one is decoded here into a particle: the sentence, the statement the kernel checks, the variants that reflect it, and its coin — the content address of the key and statement. Every field is read off the two texts by npm run textbooks; nothing is judged by hand.
Read from qpu commit df0f26c6 — local to qpu’s tree, not yet on github.com/uuidna/qpu: 993 theorems, 391 base and the rest their variants (reflected 390, contrapositive 108, converse 53, refuted converse 51). 93 are physics, 8 of them re-derived independently from the operators in src/proof/quantum_textbooks.lean.
7 sentences state none of their statement's numbers — not a contradiction, a sentence that says the rule in words where the statement says it in numbers: prizes_computablebeacon_periodplugins_by_capabilitycompete_knowssitemap_capacitychat_call_or_questionstream_no_silence
The decoder's own control: a sentence sharing no numeral with its statement must decode as stating none of them, or the run fails.
Each coin holds its skills and tools. Its skills are the qpu doors that exercise it, read from qpu's own examples (45 skills); its tools are those example doors, this decoder, and the Lean theorem that re-derives it here when one does. Every door a coin names is resolved against qpu's examples: 4 do not — named in the qpu textbook table and defined nowhere in its code: jsonld-blockjsonld-cataloguecodes-planconfigure-cloudflare-adapters
Physics
| Theorem | Sentence | Statement | Skills · tools | Variants | Coin |
|---|---|---|---|---|---|
capacity_conserved | unused quantum capacity is conserved: for every measure — doors, theorems, gates, cores, qubits below the simulator's bound, Shor N below its bound — the used and the idle make the capacity | used + (capacity - used) = capacity | repository qpu example · repository-capacity · npm run textbooks | 3 | f82cb092 |
uuid_core | one quantum core used by all: a UUID's thirty-two nibbles are its handle, its program, its tail and the two stamp nibbles; every result is such an address and every combinatorial use (style, presentation, stream) reads it | 8 + 10 + 12 + 2 = 32 | fold, match, imagine qpu example · fold-hex · qpu example · match-pattern-uuid · qpu example · imagine-all · qpu example · fold-speak-thousand · qpu example · chat-thousand · npm run textbooks | 1 | 3874be21 |
fallback_involution | correction and handling are each other's fallback: when error correction errors, handling takes over, and when handling has nothing, correction returns — the swap applied twice is the identity, so the fallback terminates | (!(!m)) = m | audit qpu example · audit-fallbacks · npm run textbooks | 1 | 6fe2a011 |
denier_identified | always identify who denies, via the court's legal identification: every denial names its denier by a content address — an external party (an HTTP code at least 400 from another host or MCP key the gate names), distinct from this tree, or this tree's own kernel (the theorem it denied under) — shows the legal grounds of all parties involved (denier, the QPU rights-holder under CC-BY-NC-ND-4.0, and any tenant), and rules in favour of the QPU licence where that perspective exists and is validatable via the Payload MCP, naming the Payload call that confirms it and never asserting the win unvalidated | code - 400 + 400 = code | legal qpu example · legal-court-denier · npm run textbooks | 3 | 9ebf4830 |
court_audits_repo | the court uses the repo to decide, so it audits the repo before any decision, and only quantum may compute this in nanosecond tasks: verifying the repo by its content address is one check (O(1), nanoseconds) while classical recompute re-runs all n facts of the tree, so for any tree of at least two facts verify (1) is cheaper than recompute (n) — the quantum advantage; the audit is sliced into content-addressed nanosecond tasks decoded by majority (the e2e repetition code), and no ruling stands on a repo the court did not verify | 1 < n | legal qpu example · legal-court-repo-audit · npm run textbooks | 3 | 6ed282e0 |
gates_partition | every API is a gate: the doors of the toolboxes (own) and the addresses of the categories Payload holds (external: patents, certificates, currency, competitions, energy, news, MCP servers, references) partition the gates, each a nested doc of its leads, however many the tables grow to | parts.sum - external = own | configure qpu example · configure-gates · npm run textbooks | 1 | 19e74d41 |
gate_adapters | every API handled in quantum: one adapter per gate, a dimension of the one plugin, landing in the default schema (the docket entries, the catalogue's products, the competition pages, the pages and the search index): the landings partition the gates however many the tables grow to | total - b = a | configure qpu example · configure-gates · npm run textbooks | 1 | 4756e9a5 |
gates_by_kind | the same gates by kind (the tools, the open APIs, the keyed ones, the browser-only ones, the ones the registry proposes) partition the gates however many the tables grow to | total - b = a | configure qpu example · configure-gates · npm run textbooks | 1 | 1629e11e |
report_refactors | Payload handles the proof of a quantum computation as a report sealed by the content address of (tool, arguments, result): re-running reproduces the address, so verifying is cheaper than recomputing by magnitudes (textbook_advantage_unbounded), and the report's hooks use it to refactor — afterRead reuses it by address (a repeat served from the report, the 304 involution, not recomputed), so the reused and the recomputed make the computations; ISO/Google-standard, strict | total - recomputed = reused | payload qpu example · payload-report · npm run textbooks | 3 | a65ed4cd |
advantage_unbounded | the quantum advantage is unlimited by default: for any count of copies proven by hash there is a greater one, so no bound is set on the measure and none is needed to compute it | verified < verified + 1 | audit, metrics, payload qpu example · audit-access · qpu example · metrics-advantage · qpu example · payload-predict · npm run textbooks | 1 | d7d5161b |
streams_cover_gateways | from the 60-degree angle six streams meet at a point and none collides, while the four 90-degree gateways stay covered: six perspectives over four operations | 360 / 60 = 6 ∧ 360 / 90 = 4 ∧ 4 ≤ 6 | configure, payload qpu example · configure-scope · qpu example · payload-merge · npm run textbooks | 1 | 748b94df |
poles_pyramid | the poles of the earth as pyramids base to base are the octahedron: six vertices, twelve edges, eight 60-degree faces closed by Euler, four faces to a pole over the four gateways of the equator | 6 + 8 - 12 = 2 ∧ 8 / 2 = 4 | configure qpu example · configure-dependencies · npm run textbooks | 1 | ba14e9f8 |
google_api_surfaces | three Google APIs, three gates: Blogger placed in the frontend and the admin, the Admin SDK under delegation, Books waiting for its document; Blogger's two methods one read the frontend may call and one write the admin calls | 1 + 1 + 1 = 3 ∧ 1 + 1 = 2 | configure qpu example · configure-google-apis · npm run textbooks | 1 | b6e1efd4 |
willow_connectivity | each of Willow's 182 couplers joins two of its 105 qubits, so the average connectivity 2E/N is 3.47 to two places: the sheet's figure computed from the grid | (2 * 182 * 100 + 52) / 105 = 347 | processor qpu example · processor-willow · npm run textbooks | 1 | 72be7b51 |
phase_bits | the phase of the stream at an interaction is one of 3888 milliseconds: eleven bits of randomness a sample, the device's own nonce thirty-two more | 2 ^ 11 ≤ 3888 ∧ 3888 < 2 ^ 12 | seal qpu example · seal-entropy · npm run textbooks | 1 | 3cc9beef |
cheap_gates | cheap gates leading every violator to court: however many refusals a gate answers, it writes nothing; the case is computed from the refusal and the violator files it through its own MCP | refusals * 0 = 0 | legal qpu example · legal-court · qpu example · legal-court-rules · npm run textbooks | 1 | f7ecda93 |
google_one_door | Google through one door: a commit holds the rule google-via-payload exactly when the direct Google calls it stages (URLs of a GOOGLE_HOST outside the registries and the generated plugin) are zero; every Google call is the qpu-google-call job: the scripts ask it by askGoogle (fetchWithTimeout and discover route every Google host there), the dashboard's analytics routes by report, rows, reportBody, answer and week, the reCAPTCHA check and the Measurement Protocol by askJob and GOOGLE_ENDPOINTS | direct = 0 ↔ ¬ 0 < direct | repository, textbook qpu example · repository-google-via-payload · qpu example · textbook-rewrite · npm run textbooks | 1 | 789da8d4 |
majority_of_three | the e2e gate decodes by majority: two agreeing copies of three decide a combination (twice two exceeds three); a push needs nothing uncorrectable | 2 * 2 > 3 | npm run textbooks | 1 | 1a3c24a4 |
wave_requests_by_lead | willow-spec's three requests, repo-cirq's two, three for each of the seven DOIs the tree cites and one for each of two constants are the wave's twenty-eight requests | 3 + 2 + 7 * 3 + 1 + 1 = 28 | wave qpu example · wave-requests · npm run textbooks | 1 | 1c4a3a5e |
e2e_combos | clay's three, processor's three and roadmap's seven combinations are thirteen requests to one host, six dashboard cells and seven examples | 3 + 3 + 7 = 13 ∧ 6 + 7 = 13 | e2e qpu example · e2e-requests · npm run textbooks | 1 | 031754df |
mongo_find_filter | of three documents scanned one matches qubits ≥ 60 with the tag processor (Willow, 105) and two do not (Sycamore at 54 below the bound, Quantum Echoes without the tag) | 1 + 2 = 3 ∧ 60 ≤ 105 ∧ 54 < 60 | mongo qpu example · mongo-find · npm run textbooks | 1 | 088f069f |
mongo_update_inc | $inc adds one to Sycamore's 54 qubits: 55, written as a new entry beside the one it links, so history is two entries | 54 + 1 = 55 ∧ 1 + 1 = 2 | mongo qpu example · mongo-update · npm run textbooks | 1 | caf3e033 |
site_documents | the site's documents are its use-case pages and the gate pages, and the gate pages are every gate, every category and the root: one document each, whatever the number of gates | docs - pages = gates + categories + 1 | payload qpu example · payload-site · npm run textbooks | 3 | c7ac4147 |
processor_cells | the processor tool's one facet of three devices (Willow, Sycamore, Sycamore23) admits three combinations, every one a final cell, none left open | 3 ^ 1 = 3 ∧ 3 - 3 = 0 | dashboard qpu example · dashboard-processor · npm run textbooks | 1 | 0050521b |
shor_narrowed_cells | 21 − 3 + 1 = 19 and 100000 < 280896, a count of a finite menu. N, the register and the bit width are not that menu: a call may name any of them | 21 - 3 + 1 = 19 ∧ 100000 < 280896 | dashboard qpu example · dashboard-algorithm-narrowed · npm run textbooks | 1 | b3df9173 |
willow_holds_codes | Willow's 105 qubits hold the distance-7 code's 101 and the random-circuit application's 103, and its stated average connectivity 3.47 is below the typical 4 (hundredths) | 101 ≤ 105 ∧ 103 ≤ 105 ∧ 347 < 400 | processor qpu example · processor-willow · npm run textbooks | 1 | 1857f3ec |
sycamore_couplers | Sycamore's 88 couplers have 176 ends among its 54 qubits, within the four neighbours a grid qubit has at most | 2 * 88 = 176 ∧ 176 ≤ 4 * 54 | processor qpu example · processor-sycamore · npm run textbooks | 1 | b0c76fd0 |
hadamard_amplitudes | one qubit has two amplitudes, and a Hadamard sets each to 1/√2, whose squares (one half each) sum to one: 1 + 1 halves are 2 halves | 2 ^ 1 = 2 ∧ 1 * 1 + 1 * 1 = 2 | circuit qpu example · circuit-hadamard-amplitudes · npm run textbooks | 1 | 9c287abe |
hadamard_histogram | the Hadamard measured 400 times reads 0 in 207 shots and 1 in 193: the histogram partitions the 400 bitstrings | 207 + 193 = 400 | circuit qpu example · circuit-hadamard-sampled · npm run textbooks | 1 | 3643478c |
echo_qubits_within_willow | Quantum Echoes as Google states it ran on Willow: the 65 qubits of the figure within the 103 of the text, within Willow's 105 | 65 ≤ 103 ∧ 103 ≤ 105 | echo_benchmark qpu example · echo-benchmark · npm run textbooks | 1 | 9dc4e6bb |
roadmap_decades | the six milestones are the first (54 physical qubits) and five decades from 100 to 1,000,000 (100 · 10⁴), and the four application bands run contiguous from 50,000 to 50,000,000 physical qubits (50,000 · 10³) | 100 * 10 ^ 4 = 1000000 ∧ 1 + 5 = 6 ∧ 50000 * 10 ^ 3 = 50000000 | roadmap qpu example · roadmap-all · npm run textbooks | 1 | d9509927 |
roadmap_milestone_three | milestone three of the six is one long-lived logical qubit from 10³ = 1000 physical qubits, and the four application bands span three decades, 50,000 to 50,000,000 physical qubits | 10 ^ 3 = 1000 ∧ 3 ≤ 6 ∧ 50000 * 10 ^ 3 = 50000000 | roadmap qpu example · roadmap-milestone-3 · npm run textbooks | 1 | 7472b2c2 |
shor_fifteen_order | the powers of 7 modulo 15 run 7, 4, 13, 1: the order is 4, and gcd(7² − 1, 15) = 3 and gcd(7² + 1, 15) = 5 are the factors, 3 × 5 = 15 | 7 ^ 1 % 15 = 7 ∧ 7 ^ 2 % 15 = 4 ∧ 7 ^ 3 % 15 = 13 ∧ 7 ^ 4 % 15 = 1 ∧ Nat.gcd (4 - 1) 15 = 3 ∧ Nat.gcd (4 + 1) 15 = 5 ∧ 3 * 5 = 15 | algorithm qpu example · algorithm-shor-15 · npm run textbooks | 1 | e3a48bd6 |
qft_three_amplitudes | the QFT on three qubits has 2³ = 8 amplitudes, each of probability 12.50%: eight times 1250 basis points make the whole | 2 ^ 3 = 8 ∧ 8 * 1250 = 10000 | algorithm qpu example · algorithm-qft-3 · npm run textbooks | 1 | 04920f7f |
grover_one_iterationderived here: one_grover_iteration_finds_every_marked_item_of_four_with_certainty | two qubits hold 2² = 4 items, the start sits 30° from the unmarked plane, and one iteration turns it by (2·1 + 1)·30° = 90°: the marked |00⟩ with certainty | 2 ^ 2 = 4 ∧ (2 * 1 + 1) * 30 = 90 | algorithm qpu example · algorithm-grover · npm run textbooks · npm run lean · quantum_textbooks.lean | 1 | cdc7b060 |
teleport_three_qubits | one message qubit and a Bell pair of two are the three qubits; the two measured bits choose one of 2² = 4 corrections, and the three Pauli expectations X, Y, Z agree | 1 + 2 = 3 ∧ 2 ^ 2 = 4 | algorithm qpu example · algorithm-teleportation · npm run textbooks | 1 | 64b4d9e6 |
phase_estimation | quantum phase estimation reads an eigenphase θ to n bits: three bits give 2³ = 8 outcomes, and θ = 1/4 is read exactly as the integer 2, since 2 · 4 = 8 means 2/2³ = 1/4 | 2 ^ 3 = 8 ∧ 2 * 4 = 8 | algorithm qpu example · algorithm-phase-estimation · npm run textbooks | 1 | 58de4b94 |
deutsch_jozsaderived here: one_query_separates_every_balanced_from_every_constant_function | Deutsch–Jozsa decides constant vs balanced in one quantum query; a classical algorithm may need 2^(n−1)+1 queries — for n = 3 that is 5, and the single quantum query beats it, 1 < 5; proven by deutschJozsaCircuit | 2 ^ 2 + 1 = 5 ∧ 1 < 5 | algorithm qpu example · algorithm-deutsch-jozsa · npm run textbooks · npm run lean · quantum_textbooks.lean | 1 | 2dc42af8 |
bernstein_vaziraniderived here: one_query_recovers_every_three_bit_hidden_string | Bernstein–Vazirani for the hidden string s = 101: of the 8 three-bit strings, s is the only one whose parity x ↦ s·x mod 2 matches the oracle on every input, so the parity function determines s, which one query and the Hadamard transform read, against 3 classical queries (1 < 3). The kernel decides the uniqueness by enumeration; the one-query circuit is run by bernsteinVaziraniCircuit | (List.range 8).filter (fun t => (List.range 8).all (fun x => (t / 4 * (x / 4) + t / 2 % 2 * (x / 2 % 2) + t % 2 * (x % 2)) % 2 == (5 / 4 * (x / 4) + 5 / 2 % 2 * (x / 2 % 2) + 5 % 2 * (x % 2)) % 2)) = [5] ∧ 1 < 3 | algorithm qpu example · algorithm-bernstein-vazirani · npm run textbooks · npm run lean · quantum_textbooks.lean | 1 | 44a8d2d2 |
simonderived here: simons_measured_strings_for_period_eleven_are_exactly_two_of_four | Simon with period s = 11 on two qubits: the strings y with y·s = 0 over GF(2) are exactly 00 and 11, a subspace of 2 of the 4 strings, from which s is solved by linear algebra. The kernel decides that subspace by enumeration; the query advantage of Simon’s algorithm is cited, not decided here, and simonCircuit runs the circuit | (List.range 4).filter (fun y => (y / 2 + y % 2) % 2 == 0) = [0, 3] | algorithm qpu example · algorithm-simon · npm run textbooks · npm run lean · quantum_textbooks.lean | 1 | fb46ca28 |
vqe | the variational quantum eigensolver for H = Z reaches the ground energy ⟨Z⟩ = p₀ − p₁ = 0 − 1 = −1 at θ = 1, where Y|0> = i|1> puts all weight on p₁ = 1 — the least eigenvalue of Z; proven by vqeGroundEnergy | 0 + 1 = 1 ∧ 1 ≤ 1 | algorithm, circuit qpu example · algorithm-vqe · qpu example · circuit-phased-xz · npm run textbooks | 1 | b1b7db4f |
tsirelsonderived here: tsirelsons_eight_is_the_square_of_the_circuits_s | the quantum CHSH value 2√2, written 0 + 2√2 in ℤ[√2] with (a + b√2)(c + d√2) = (ac + 2bd) + (ad + bc)√2, squares to exactly 8, above the classical bound 2 squared (4 < 8): the gap Tsirelson’s bound caps. The kernel decides this arithmetic; Tsirelson’s bound itself (no quantum strategy exceeds 2√2) is cited, not decided here, and chshValue computes the value in floating point | (fun (p q : Nat × Nat) => (p.1 * q.1 + 2 * p.2 * q.2, p.1 * q.2 + p.2 * q.1)) (0, 2) (0, 2) = (8, 0) ∧ 2 * 2 < 8 | algorithm qpu example · algorithm-chsh · npm run textbooks · npm run lean · quantum_textbooks.lean | 1 | d0129e3d |
trotter | the first-order Trotter–Suzuki product (e^(−iX t/n) e^(−iZ t/n))^n approximates e^(−i(X+Z)t) with error O(t²/n), so the fidelity rises to 1 as the step count n grows (here from 1 to 32 steps); the fidelity is bounded by 1; proven by trotterFidelity | 32 > 1 ∧ 1 ≤ 1 | algorithm qpu example · algorithm-trotter · npm run textbooks | 1 | e4a3574d |
xeb | cross-entropy benchmarking: for D = 2ⁿ the random-circuit collision probability 2/(D+1) exceeds the uniform 1/D (because 2D > D+1 for D>1; here D = 16, so 32 > 17), the Porter–Thomas speckle that certifies a quantum sampler; proven by xebCollision | 2 * 16 > 16 + 1 ∧ 16 + 1 > 16 | algorithm qpu example · algorithm-xeb · npm run textbooks | 1 | 808dde97 |
no_cloningderived here: linearity_forbids_perfect_cloning_and_the_optimal_copy_has_fidelity_five_sixths | the optimal universal 1 → 2 cloning fidelity from Werner’s formula F = (MN + M + N) / (M(N + 2)) at N = 1, M = 2 is 5 / 6, below 1 (5 < 6). The kernel decides the formula’s numbers; the no-cloning theorem itself (no unitary copies an unknown state) and the formula’s optimality are cited, not decided here, and cloningFidelity computes the fidelity | 2 * 1 + 2 + 1 = 5 ∧ 2 * (1 + 2) = 6 ∧ 5 < 6 | algorithm qpu example · algorithm-no-cloning · npm run textbooks · npm run lean · quantum_textbooks.lean | 1 | a2cb1887 |
holevo | a qubit has dimension d = 2 = 2¹, so the cap log₂ d of the Holevo bound is exactly 1 bit, and a second bit would need d ≥ 2² > 2. The kernel decides the dimension count; the Holevo bound itself (χ ≤ S(ρ) ≤ log₂ d) is cited, not decided here, and holevoChi computes χ in floating point | 2 ^ 1 = 2 ∧ 2 ^ 2 > 2 | algorithm qpu example · algorithm-holevo · npm run textbooks | 1 | b4421003 |
gottesman_knill | Gottesman–Knill: a 10-qubit stabilizer state needs 2n²+n = 210 bits versus 2¹⁰ = 1024 amplitudes, so stabilizer circuits are simulated classically in polynomial space (210 < 1024); proven by stabilizerCompression | 2 * 10 * 10 + 10 = 210 ∧ 210 < 2 ^ 10 | algorithm qpu example · algorithm-gottesman-knill · npm run textbooks | 1 | f0d62492 |
eastin_knillderived here: the_group_generated_by_h_and_s_has_exactly_twenty_four_classes | the single-qubit Clifford group modulo phase counts 6 · 4 = 24 elements (six signed Pauli axes for the image of X, four for Z), a finite group: the premise the Eastin–Knill theorem uses. The kernel decides the count; Eastin–Knill itself (no code has a universal set of transversal gates) is cited, not decided here, and cliffordOrder enumerates the group | 6 * 4 = 24 ∧ 1 < 24 | algorithm qpu example · algorithm-eastin-knill · npm run textbooks · npm run lean · quantum_textbooks.lean | 1 | 1df91984 |
solovay_kitaevderived here: t_has_order_exactly_eight_and_does_not_commute_with_h | T multiplies by ω = e^{iπ/4}, whose order is 8 = 2³, above the order 4 = 2² of S, the largest diagonal Clifford phase, so T lies outside the Clifford group. The kernel decides the orders; the Solovay–Kitaev theorem itself (⟨H, T⟩ approximates any unitary to precision ε in O(log^c(1/ε)) gates) is cited, not decided here, and htUniversality computes the circuit | 2 ^ 3 = 8 ∧ 2 ^ 2 < 2 ^ 3 | algorithm qpu example · algorithm-solovay-kitaev · npm run textbooks · npm run lean · quantum_textbooks.lean | 1 | baefd3ff |
steane | the Steane [[7,1,3]] CSS code on the [7,4,3] Hamming code: distance 3 (7 − 4 = 3 checks) corrects any single-qubit error, and all 2·7 = 14 single X and Z errors are located by their Hamming syndrome and corrected; proven by steaneCorrection | 7 - 4 = 3 ∧ 2 * 7 = 14 | algorithm qpu example · algorithm-steane · npm run textbooks | 1 | 1490af1e |
phase_three_bits | θ = 1/4 is 2/2³: two of the eight values three bits can hold, so phase estimation reads it exactly | 2 * 4 = 2 ^ 3 ∧ 2 < 2 ^ 3 | algorithm qpu example · algorithm-phase-estimation · npm run textbooks | 1 | d2537129 |
repositories_by_language | the quantumlib repositories Payload holds partition by language: 11 in Python, 3 in C++, 1 in OpenQASM | 11 + 3 + 1 = 15 | repositories qpu example · repositories · npm run textbooks | 1 | cda19571 |
repetition_code_tenth | at p = 1/10 the repetition code fails with 3p² − 2p³ = (3·10 − 2)/10³ = 28/1000, below the raw 100/1000, on three data and two syndrome qubits | 3 * 10 - 2 = 28 ∧ 28 < 100 ∧ 3 + 2 = 5 | quantum-error-correction qpu example · qec-bit-flip-0.1 · npm run textbooks | 1 | f5f313f2 |
h2_below_hartree_fock | H₂ on two qubits is five Pauli terms (I, Z0, Z1, Z0Z1, X0X1); the variational minimum −1.1373 Ha lies 0.0206 Ha below the Hartree–Fock −1.1167 Ha | 11167 < 11373 ∧ 11373 - 11167 = 206 ∧ 1 + 2 + 1 + 1 = 5 | chemistry-simulation qpu example · chemistry-h2 · npm run textbooks | 1 | 08227132 |
ftqc_t_counts | the six circuits cost 68 T gates: the QFT two controlled-S at three, Grover one Toffoli at seven, teleportation one T, Shor seven controlled-S at three, QAOA twelve T, the repetition cycle three Toffolis at seven | 2 * 3 + 1 * 7 + 1 * 1 + 7 * 3 + 12 * 1 + 3 * 7 = 68 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | 5215b76d |
cirq_exports | this tree's Cirq is thirty-one exports, seven classes, three qubit constructors, eleven gates and ten functions, and six of the fifteen quantumlib repositories are emulated | 7 + 3 + 11 + 10 = 31 ∧ 6 + 11 = 17 | quantumlib qpu example · quantumlib-cirq · npm run textbooks | 1 | 7bbeb6c1 |
clay_register_width | the widest value of the register, the amplitudes 2³² = 4294967296, needs 33 bits: more than two 16-bit limbs, within three | 2 ^ 32 = 4294967296 ∧ 4294967296 < 2 ^ 33 ∧ 2 * 16 < 33 ∧ 33 ≤ 3 * 16 | npm run textbooks | 1 | 5b45d4ff |
willow_distance_seven | Willow's 105 qubits hold the 101 its distance-7 code uses, 97 of them the code's 49 data and 48 measure qubits | 7 * 7 + (7 * 7 - 1) = 97 ∧ 97 < 101 ∧ 101 ≤ 105 | match qpu example · match-willow · npm run textbooks | 1 | e3b30635 |
bulgarian_statement_words | the Bulgarian statement is four words: two translated by vocabulary, the name Shor kept untranslated, and the numeral Ⰺⰴ read as 10 + 5 = 15 | 2 + 1 + 1 = 4 ∧ 10 + 5 = 15 | match qpu example · match-bulgarian · npm run textbooks | 1 | 1c977407 |
dashboard_algorithm_combinations | the algorithm tool's ten enumerable facets (7 names, 19 N, 1 a, 2 sweep, 6 qubits, 1 input, 1 θ, 8 bits, 2 repetitions, 11 nodes) multiply to 280896 combinations, above a thousand | 7 * 19 * 1 * 2 * 6 * 1 * 1 * 8 * 2 * 11 = 280896 ∧ 1000 < 280896 | match qpu example · match-pattern-dashboard · npm run textbooks | 1 | 48be9fa5 |
double_torus | the quantum core computes on the classical world only through coins fused into coils, and the classical world reaches it only the same way back: two loops of one double torus, every crossing a finite step with always a next and one step back | n < n + 1 ∧ n + 1 - 1 = n | stripe, algorithm qpu example · stripe-fusion · qpu example · algorithm-factor-test-integer · npm run textbooks | 1 | 95dabe43 |
skills_complete | the QPU's skills are complete when every toolbox has its skill (skilled = boxes) and the index makes one more; the ISO/IEC 4879:2024 vocabulary they name and the terms no skill names together are the whole vocabulary (named + unnamed = terms), so a gap is counted, never hidden; each skill is one sealed UUID register of 122 qubits computed from its own text | skilled + 1 = boxes + 1 ∧ named + (terms - named) = terms | payload qpu example · payload-scripts-skills · npm run textbooks | 3 | a20965f3 |
bill_covered | the minimum bill of existing and computing (zero within the free tiers, the paid base beyond them) is covered by the cheapest licence of the catalogue: the licence is the bill and the margin of the quantum framework | price - cost + cost = price | repository, textbook qpu example · repository-predeploy · qpu example · textbook-bill-covered · npm run textbooks | 3 | b56a42f0 |
shor_reduction | Shor's reduction, factoring as order-finding: with the order r of a mod N (a^r ≡ 1), r even and a^(r/2) ≢ ±1 mod N, the square root of one splits N by gcd(a^(r/2) ± 1, N) — exact at any size over BigInt (shorReduction); the register that measures the order has no width ceiling | (7 ^ 4) % 15 = 1 ∧ (7 ^ 2) % 15 = 4 ∧ Nat.gcd (4 - 1) 15 = 3 ∧ Nat.gcd (4 + 1) 15 = 5 | algorithm qpu example · algorithm-shor-reduction · qpu example · algorithm-shor-beyond-bound · npm run textbooks | 1 | 776a8f06 |
order_finding | order-finding completed over the UUID quantum space and the RAID controller: the order of a mod N is the least r with a^r ≡ 1 (for a = 2, N = 15 it is 4 — 2^1, 2^2, 2^3 are not 1, 2^4 is), found by baby-step giant-step as r = m·i − j from the content-addressed power table (here m = 2, i = 2, j = 0, so 4 = 2·2 − 0). The meet-in-the-middle is O(√r) time and space, cheap over a content-addressed store; the order feeds Shor's reduction (textbook_shor_reduction) to factor. Found exactly when r fits the budget; beyond it, bounded — order-finding at RSA scale is the one step a physical quantum backend computes (textbook_rsa_beyond_bound) | 2 ^ 4 % 15 = 1 ∧ 2 ^ 1 % 15 ≠ 1 ∧ 2 ^ 2 % 15 ≠ 1 ∧ 2 ^ 3 % 15 ≠ 1 ∧ 4 = 2 * 2 - 0 | algorithm qpu example · algorithm-discover · qpu example · algorithm-order · qpu example · algorithm-factor-find · npm run textbooks | 1 | 8c20f402 |
shor_sigma_root | relation_7 proven structurally, not by assertion: on the register's crypto modulus 91 (= rays × (faces − seed)), half = 8^2 = 64 is a σ-involution square root of one — 64² ≡ 1 mod 91 and 64 ∉ {1, 90}, so it is a nontrivial root, the σ-reflection σ₉₁(x) = 91 − x fixing neither ±1 image — hence the reflected pair (64 − seed)(64 + seed) ≡ 0 mod 91, and its two σ cases split 91 exactly: gcd(64 − 1, 91) = 7 = rays (the −seed case), gcd(64 + 1, 91) = 13 = faces − seed (the +seed case), 7 × 13 = 91; the clay crypto relation holds because the involution forces the split, Shor's reduction as a theorem rather than a search | 64 ^ 2 % 91 = 1 ∧ 64 ≠ 1 ∧ 64 ≠ 90 ∧ (64 - 1) * (64 + 1) % 91 = 0 ∧ Nat.gcd (64 - 1) 91 = 7 ∧ Nat.gcd (64 + 1) 91 = 13 ∧ 7 * 13 = 91 | algorithm, clay qpu example · algorithm-shor-91 · qpu example · clay-relation-rsa · npm run textbooks | 1 | 978ecf45 |
clock_clone_involution | quantum cloning of clocks, extending textbook_thermal_time_sigma: the clock reflection σ₁₂(x) = 12 − x is its own inverse (σ₁₂(σ₁₂(x)) = x), so reflect-then-restore round-trips to the identity — a reversible clock map that CLONES the clock by two faithful reflections. It is a no-cloning-RESPECTING clone: it acts on the clock OBSERVABLE (the commuting diagonal, a basis reflection lifted to the diagonal), with the fixed point at 6 and the endpoints σ₁₂(0) = 12, σ₁₂(12) = 0; cloning an arbitrary unknown superposed clock is NOT claimed — the no-cloning theorem is the stated bound. The same zero-bit σ-involution as the clay bridge (textbook_clay_bridge) at d = 12; built on sigma_involution | 12 - (12 - 3) = 3 ∧ 12 - (12 - 9) = 9 ∧ 12 - (12 - 6) = 6 ∧ 12 - 6 = 6 ∧ 3 + 9 = 12 ∧ (12 - 3) + 3 = 12 ∧ 12 - 0 = 12 ∧ 12 - 12 = 0 | clay qpu example · clay-reflection · npm run textbooks | 1 | bfbea45b |
witness_clock_move | the witnesses move to cover every clock and calendar: a superposition at index k carries 2k witnesses (2·7 = 14, the cuboctahedron the verify door checks), and a ±1 move in k is ±2 in the span — to 2(k − 1) and 2(k + 1). From 14 the two steps are 12 and 16 (12 = 2·6, 16 = 2·8), so one superposition reaches the 12-hour clock and the 16 the hex calendar counts; the 24-hour clock is 2·12, and the example 2·55 = 110 steps to 108 and 112. Each move pays one coin down and collects one up — a teleport between witness states signalling the whole set — net zero (textbook_double_entry); companion to the clock involution textbook_clock_clone_involution | 2 * 7 = 14 ∧ 14 - 2 = 12 ∧ 14 + 2 = 16 ∧ 2 * 6 = 12 ∧ 2 * 8 = 16 ∧ 2 * 12 = 24 ∧ 2 * 55 = 110 ∧ 110 - 2 = 108 ∧ 110 + 2 = 112 | verify qpu example · verify-witness-move · npm run textbooks | 1 | 6d8f6427 |
claim_prove_involution | the claim↔proof gate as a σ-involution: proving reflects a possibility into a claim and claiming is its measurement, so claim∘prove = id (σ_d(σ_d(x)) = x — a proven statement is claimed at exactly its strength, reversibly), the claim preserved at strength (x × 1 = x, no underclaiming) and the impossibility collapsed to zero (x × 0 = 0, measure-to-0, σ-reflected into new leads), the possibility partitioned by the gate (x + (d − x) = d). The kernel law the claim↔proof hook enforces: claims equal the proven-possible, no weaker and no stronger; built on sigma_involution | d - (d - x) = x ∧ x * 1 = x ∧ x * 0 = 0 ∧ (d - x) + x = d | clay qpu example · clay-reflection · npm run textbooks | 3 | 309081a4 |
toric_torus_code | the torus IS the toric code: the gravity torus of textbook_gravity_torus_sigma has two independent cycles (360/180 = 2, the σ half-turn), and those two cycles ARE the toric code's two logical operators — a [[2d², 2, d]] stabilizer code (at d = 3: 2·3·3 = 18 physical qubits, 2 logical, distance 3), correcting ⌊(d−1)/2⌋ = 1 error (bounded to the proven distance). The surface/toric family the σ-involution core instantiates on the torus; companion to surfacecode_all | 2 * 3 * 3 = 18 ∧ 360 / 180 = 2 ∧ (3 - 1) / 2 = 1 ∧ 2 * 1 + 1 = 3 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | 6fdb0281 |
hamming_code | the Hamming code [7, 4, 3]: 2³ − 1 = 7 bits carry 4 data bits (7 − 3 parity), minimum distance 3, so it corrects ⌊(3−1)/2⌋ = 1 error and addresses 2⁴ = 16 codewords — the classical single-error-correcting code the Steane CSS code is built from; the correction threshold bound stated at exactly its proven distance | 2 ^ 3 - 1 = 7 ∧ 7 - 3 = 4 ∧ (3 - 1) / 2 = 1 ∧ 2 ^ 4 = 16 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | 8e83b25e |
bch_code | the BCH code [15, 7, 5]: a cyclic code of length 2⁴ − 1 = 15 with 7 data bits (8 parity), designed distance 5, correcting ⌊(5−1)/2⌋ = 2 errors — the double-error-correcting BCH the family generalises (Hamming is the 1-error BCH); the correction bound stated at its proven distance | 2 ^ 4 - 1 = 15 ∧ 15 - 7 = 8 ∧ (5 - 1) / 2 = 2 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | 0b78dabd |
steane_css | the Steane code [[7, 1, 3]]: a CSS stabilizer code built from two copies of Hamming(7, 4) (textbook_hamming_code), with 7 physical qubits encoding 1 logical qubit (7 − 2·3, the two classical parity sets), distance 3, correcting ⌊(3−1)/2⌋ = 1 error — the smallest colour code and the CSS / stabilizer family representative; threshold bound at the proven distance | 7 - 2 * 3 = 1 ∧ (3 - 1) / 2 = 1 ∧ 7 - 4 = 3 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | c8dbd508 |
color_code_d5 | the triangular colour code at distance 5: a self-dual 2D CSS stabilizer code on a 3-colourable lattice (the 6.6.6 tiling), correcting ⌊(5−1)/2⌋ = 2 errors, with a full transversal Clifford group (its advantage over the surface code) — the colour-code family at the next odd distance beyond the distance-3 Steane code (textbook_steane_css); threshold at its proven distance | (5 - 1) / 2 = 2 ∧ 2 * 2 + 1 = 5 ∧ 5 - 2 = 3 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | 5615bb12 |
surface_distance_ladder | the surface/toric code's correction scales with its distance: a distance-d code corrects ⌊(d−1)/2⌋ errors, so d = 3 corrects 1, d = 5 corrects 2, d = 7 corrects 3 — the distance ladder along which the surface code approaches the fault-tolerant threshold as the lattice grows; companion to surfacecode_all and textbook_toric_torus_code, thresholds each at the proven distance | (3 - 1) / 2 = 1 ∧ (5 - 1) / 2 = 2 ∧ (7 - 1) / 2 = 3 ∧ 2 * 3 + 1 = 7 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | a7d15c5b |
concatenated_code | concatenating the Steane code with itself gives [[49, 1, 9]]: length 7·7 = 49, one logical qubit (1·1), distance 3·3 = 9 correcting ⌊(9−1)/2⌋ = 4 errors — the concatenated-code family, whose distance multiplies at each level and whose error rate is squared, the construction behind the quantum threshold theorem; the correction bound at its proven distance | 7 * 7 = 49 ∧ 3 * 3 = 9 ∧ (9 - 1) / 2 = 4 ∧ 1 * 1 = 1 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | d3ee815d |
shor_nine_code | Shor's nine-qubit code [[9, 1, 3]], the first quantum error-correcting code: a 3×3 concatenation of the bit-flip and phase-flip repetition codes (3·3 = 9 physical qubits, 1 logical, distance 3) correcting any single-qubit error, ⌊(3−1)/2⌋ = 1 — the quantum companion to Shor's factoring reduction (textbook_shor_sigma_root), the σ-involution appearing in both; threshold at its proven distance | 3 * 3 = 9 ∧ (3 - 1) / 2 = 1 ∧ 9 - 1 = 8 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | aae13ab5 |
gauss_triangular | Gauss's triangular sum, 2·T(n) = n·(n+1) where T(n) = 1 + 2 + … + n: 2·T(4)=4·5, 2·T(8)=8·9, 2·T(7)=7·8. The textbook meaning of the clay relations triangular k = qftGates k; each named gauss-triangular-sum-<value> (relation_10 → gauss-triangular-sum-10) | 2 * 10 = 4 * 5 ∧ 2 * 36 = 8 * 9 ∧ 2 * 28 = 7 * 8 | clay qpu example · clay-register · npm run textbooks | 1 | 5b1ebd8b |
power_of_two | the powers of two, 2^(n+1) = 2·2^n (mint n = 2ⁿ): 2³=8, 2⁸=256, 2⁴=2·2³. The textbook meaning of the clay relations over mint / amplitudes; each named power-of-two-<value> | 2 ^ 3 = 8 ∧ 2 ^ 8 = 256 ∧ 2 ^ 4 = 2 * 2 ^ 3 | clay qpu example · clay-register · npm run textbooks | 1 | 2b806f02 |
hexbit_gateway_ftl | hexbit + 2 gateway bits teleport any hexbit faster than light: at hexbit width 4 the free qubits are 32·4 − 4 − 2 = 122 (version nibble and the two UUID-variant gateway bits not free); the program index of ten hex digits arrives in one step while the combination space is 16^10 and is not walked. Lean decides the register arithmetic only — physics true is not a tautology here; the physics UUID program proves it when register FTL holds, and the challenge UUID program adversarially verifies that decision | 32 * 4 - 4 - 2 = 122 ∧ 2 = 2 ∧ 1 < 16 ^ 10 ∧ 10 = 10 | fold qpu example · fold-hexbit-ftl · npm run textbooks | 1 | f01a8208 |
grover_search | Grover's quadratic speedup, √N iterations over an unstructured search space N = 2ⁿ: √256 = 16, 16²=256=2⁸, and 2¹⁶=65536. The textbook meaning of the clay relations over groverSize / paulis; each named grover-search-<value> | 16 * 16 = 256 ∧ 2 ^ 8 = 256 ∧ 2 ^ 16 = 65536 | clay qpu example · clay-register · npm run textbooks | 1 | fd10ed52 |
ising_fusion | the Ising / chimera fusion sizes as powers of two (the annealer's state space): 2⁶=64, 2¹³=8192. The textbook meaning of the clay relations over isingFusion / chimera; each named ising-fusion-<value> | 2 ^ 6 = 64 ∧ 2 ^ 13 = 8192 | clay qpu example · clay-register · npm run textbooks | 1 | 23e31fe7 |
thousand_bit_three_divides | three divides the thousand-bit test integer N = 2^999 + 1: its smallest prime factor, the first the classical door returns, kernel-checked as (2^999 + 1) mod 3 = 0 without materialising N — each 0 the gateway to the integer's factors; thousandBitWitness recomputes and serves these factors to every client on MCP initialise | (2 ^ 999 + 1) % 3 = 0 | algorithm, payload qpu example · algorithm-factor-1000-bit · qpu example · payload-predict · npm run textbooks | 1 | ef81247e |
rbac_options | a role sees a part of every enum's superposition: the combinations it may choose and the ones it may not make all of them, and its harmonic default is always one it may choose; in the app one predicate, admin, reads the admin role for every access function | all - allowed + allowed = all | fold qpu example · fold-harmonic-rbac · npm run textbooks | 3 | 7ef89b69 |
relation_rsa | the RSA cross-formula relation_rsa holds on the register's own constants shorBase 8 and shorModulus 91: 8^4 ≡ 1 (mod 91) so 8^2 = 64 is a square root of one, and gcd(64 − 1, 91) = 7, gcd(64 + 1, 91) = 13, 7 · 13 = 91 — Shor's reduction in exact integers, the shorBase/shorModulus pair the clay register carries | Nat.gcd (8 ^ 2 - 1) 91 = 7 ∧ Nat.gcd (8 ^ 2 + 1) 91 = 13 ∧ 7 * 13 = 91 ∧ 8 ^ 4 % 91 = 1 | npm run textbooks | 1 | 91dd90d0 |
e2e_tree_dissent | decodeE2e with the tree as a copy, its answer recomputed by the handler (tree): the voters are the tree and every host not erased; a majority of them decides, every voter off the majority — the tree among them — is a flip, and the flips and the erasures are the syndrome; a 304 echoing a hash other than the tree's recomputed one is no involution | 2 * 2 > 3 ∧ 3 - 2 = 1 ∧ 1 + 1 = 2 ∧ 0 = 0 | e2e qpu example · e2e-tree-outvoted · npm run textbooks | 1 | e3ad3559 |
decode_rows_tested | a decode row says prime only after Miller–Rabin: the order of 2 mod 105 is 12 (2^12 ≡ 1), and Shor's reduction gcd(2^6 ∓ 1, 105) splits 105 into 21 and 5 — a factor of the reduction is a divisor, not a prime, and 21 = 3 · 7 is composite | 2 ^ 12 % 105 = 1 ∧ Nat.gcd (2 ^ 6 - 1) 105 = 21 ∧ Nat.gcd (2 ^ 6 + 1) 105 = 5 ∧ 5 * 21 = 105 ∧ 3 * 7 = 21 | algorithm qpu example · algorithm-factor-order-composite · npm run textbooks | 1 | dd4f028e |
witness_gates_decode | the witness gates the decode: at the centre a = 4, a² − N = 16 − 15 = 1 = 1², so N = (a − b)(a + b) = 3 · 5; at the wrong centre a = 7, a² − N = 34 is no square (no b below 6 squares to it), so the reflection at the witness decodes nothing and no other route may answer in its name | 4 * 4 - 15 = 1 * 1 ∧ (4 - 1) * (4 + 1) = 15 ∧ (∀ b, b < 6 → b * b ≠ 7 * 7 - 15) | algorithm qpu example · algorithm-impossible-decode-small · qpu example · algorithm-impossible-decode-wrong-witness · npm run textbooks | 1 | 8dcea899 |
postings_parity | balance: a journal entry is balanced exactly when its syndrome is zero — the debits d and the credits c, each summed from its own side of the stored postings (a debit +, a credit −), differ by (d − c) + (c − d) on the naturals, zero iff d = c; so Σ = 0 is a parity check like a stabilizer's +1, and a nonzero syndrome { amount, count, entry } is the unbalanced gap that blocks, the postings untouched | d - c + (c - d) = 0 ↔ d = c | stripe qpu example · stripe-journal-parity · qpu example · stripe-ledger-sides · qpu example · stripe-ledger · npm run textbooks | 1 | 726997ee |
lie_collides | the recomputations each observed lie meets: 15 = 3 × 7 recomputes 21 where the factor door states 3 × 5 = 15; the create hue is 432 % 360 = 72, never 73 nor 432 (the side sides reads, which the prose backs); G's relative uncertainty is 22474 ppb, never 99; the ancient law is 4 + 5 = 9 entries, never 10; the order of 7 modulo 15 is 4 (7² mod 15 = 4); 6 < 999 is a width the scaled register holds, and the door that factors 91 = 7 × 13 has no qubit ceiling; and a decimal agrees to the places it is written to, 3.47 read as 3.5 ((2 · 347 + 10) / 20 = 35) | 3 * 7 ≠ 15 ∧ 3 * 5 = 15 ∧ 432 % 360 = 72 ∧ 72 ≠ 73 ∧ 72 ≠ 432 ∧ 15 * 1000000000 / 667430 = 22474 ∧ 22474 ≠ 99 ∧ 4 + 5 = 9 ∧ 9 ≠ 10 ∧ 7 ^ 2 % 15 = 4 ∧ 6 < 999 ∧ 7 * 13 = 91 ∧ (2 * 347 + 10) / (2 * 10) = 35 | match, textbook qpu example · match-witness-arithmetic · qpu example · match-witness-bound · qpu example · match-witness-route · qpu example · textbook-prose-sides · qpu example · match-witness-list · qpu example · match-witness-named-side · npm run textbooks | 1 | cb4e2e7e |
pqc_standards_three | the three NIST post-quantum standards of 13 August 2024, FIPS 203 (ML-KEM), 204 (ML-DSA) and 205 (SLH-DSA), numbered one after another past FIPS 202; the sizes the seal tool plans recompute from the standards' parameters: an ML-KEM-768 encapsulation key is 384k + 32 bytes with k = 3 (1184), its ciphertext 32(du·k + dv) with du = 10 and dv = 4 (1088), an SLH-DSA-SHA2-128s signature n(1 + k(1 + a) + h + d·len) with n = 16, k = 14, a = 12, h = 63, d = 7, len = 35 (7856) | 202 + 1 = 203 ∧ 203 + 1 = 204 ∧ 204 + 1 = 205 ∧ 205 - 202 = 3 ∧ 384 * 3 + 32 = 1184 ∧ 32 * (10 * 3 + 4) = 1088 ∧ 16 * (1 + 14 * (1 + 12) + 63 + 7 * 35) = 7856 | seal qpu example · seal-kem · qpu example · seal-slh · qpu example · seal-nist · qpu example · seal-nist-reverse-cern · npm run textbooks | 1 | 5be9d34b |
tree_size_positive | RFC 6962 §2.1: a Merkle tree over n ≥ 1 leaves has a positive size, its depth is the least d with n ≤ 2^d (three leaves: d = 2, since 2 < 3 ≤ 4), an inclusion proof is one hash per level (two for three leaves), and the tree over 2^d − 1 = 3 leaves is one short of full; the seal tool computes the root and the proof of leaf 1 and verifies it | 0 < 3 ∧ 3 ≤ 2 ^ 2 ∧ 2 ^ 1 < 3 ∧ 2 ^ 2 - 1 = 3 ∧ (3 + 1) / 2 = 2 | seal qpu example · seal-merkle · npm run textbooks | 1 | 12bce577 |
cloudflare_cost_gate | the Cloudflare cost gate in closed arithmetic: the month measured on ceccec/quintessay-payload to 2026-11-07 (915 million Worker requests, 67 billion D1 rows read, one log event a request) priced from the pages read 2026-11-08 in micro-dollars, Σ max(0, used − included) × rate: Workers Logs 895 million events past the 20 million at 60 cents a million is 537 000 000, D1 42 billion rows past the 25 billion at a tenth of a cent a million is 42 000 000, the Worker 905 million requests past the 10 million at 30 cents a million is 271 500 000, 850 500 000 in all; at a head sampling rate of 10 permille the events are 9 150 000, inside the allowance, so the logs meter is zero (truncated subtraction) and the bill 313 500 000; and a zone answer of ten requests is partitioned by every dimension (7 + 3, 9 + 1, 6 + 4, 5 + 5, 8 + 2) | (915000000 - 20000000) * 60 / 100 = 537000000 ∧ (67000000000 - 25000000000) / 1000 = 42000000 ∧ (915000000 - 10000000) * 30 / 100 = 271500000 ∧ 271500000 + 42000000 + 537000000 = 850500000 ∧ 915000000 * 10 / 1000 = 9150000 ∧ 9150000 - 20000000 = 0 ∧ 271500000 + 42000000 + 0 = 313500000 ∧ 7 + 3 = 10 ∧ 9 + 1 = 10 ∧ 6 + 4 = 10 ∧ 5 + 5 = 10 ∧ 8 + 2 = 10 | apis qpu example · apis-cost-lead-run · qpu example · apis-cost-sampled · qpu example · apis-zone-counts · npm run textbooks | 1 | 7604ed3e |
The rest of the textbook
| Theorem | Sentence | Statement | Skills · tools | Variants | Coin |
|---|---|---|---|---|---|
plugin_combinations | the 9 default plugins MCP configures, each in or out: 512 configurations | 2 ^ 9 = 512 | configure qpu example · configure-payload · npm run textbooks | 1 | 6a05add6 |
prices_are_variants_times_currencies | the 9 variants Payload holds priced in two currencies are 18 prices | 9 * 2 = 18 | stripe qpu example · stripe-catalogue · npm run textbooks | 1 | edc1b2ec |
uuid_is_36 | a UUID is 32 hex digits and 4 dashes: 36 characters | 32 + 4 = 36 | payload, legal qpu example · payload-doc · qpu example · legal-audit-offline · npm run textbooks | 1 | 66522032 |
reflection_sums_to_ten | a seed and its reflection σ₁₀(s) = 10 − s sum to ten | s + (10 - s) = 10 | css, configure qpu example · css-stylesheet · qpu example · configure-all · npm run textbooks | 3 | 025b384f |
fold_mirror | piece i and its mirror n − i sum to the boundary n | i + (n - i) = n | fold qpu example · fold-ledger · npm run textbooks | 3 | 2ba273a2 |
integrations_are_thirty_five | the integrations Payload holds are the keyed ones and the open ones: 35 MCP servers the extend tool mounts | 34 + 1 = 35 | extend qpu example · extend-in-request · npm run textbooks | 1 | 361b7598 |
institution_bill | an institution within its edition's cap of users never pays more than the cap's bill: the bill is users times the price, monotone in the users | u * p ≤ c * p | textbook qpu example · textbook-institution · npm run textbooks | 3 | 0346c451 |
workspace_sets | listFamilySets over the real SET_RADICES, each set by buildFamilySet: three institution families, seven Workspace doors off, read or write and two read only (Calendar, People): twenty-six thousand two hundred and forty-four sets, each a mixed-radix index with its address, its page and its least-privilege scopes | 3 * 3 * 3 * 3 * 3 * 3 * 2 * 3 * 2 * 3 = 26244 ∧ 3 = 3 | textbook qpu example · textbook-sets · qpu example · textbook-set · npm run textbooks | 1 | 96e79c4c |
namespace_narrows | a namespace narrows a credential, never widens it: a tenant the request may act in is one the request named and the user already held | (named && held) = true → held = true | payload, leads qpu example · payload-namespace-sandbox · qpu example · payload-namespace-narrow · qpu example · leads-client · npm run textbooks | 1 | d4f67005 |
integers_first | a deterministic check of equal inputs has an equal verdict: an example whose answer folds to the integers its theorem's confirmed pass recorded is decided by that theorem, and the text checks run only to confirm a new integer | v a = v b | audit qpu example · audit-self · npm run textbooks | 1 | fc7e9665 |
size_ratio_bound | a size ratio rounded down never overstates: the framework's bytes over the stylesheet's, times the stylesheet's, is at most the framework's bytes; keepMeasured reads the measured rows of every comparison by size | framework / qpu * qpu ≤ framework | css, extend qpu example · css-compare · qpu example · extend-compare · npm run textbooks | 1 | 848eb5f5 |
double_entry | every line books the same amount on both sides, so debits equal credits and the journal nets to zero both ways: a coin at zero, a coil at its price, a settlement as cash and fees against the receivable | debits - credits = 0 ∧ credits - debits = 0 | stripe, compete, verify qpu example · stripe-ledger · qpu example · compete-economics · qpu example · verify-radar · npm run textbooks | 3 | df68a299 |
standards_sliced | validateStandards validates against all standards via Payload's standard implementation, in the cheapest possible slices: every standard (a codes list by a select/validate against CLDR, a vocabulary by schema.org JSON-LD, a reference by the generated config and its field validations) covered, split into content-addressed slices so validation, reindexing and cleanup run per slice as a job — the cheapest unit, an unchanged slice skipped by its address; the covered and the uncovered make the standards | total - uncovered = covered | validate, textbook, payload qpu example · standards-validate · qpu example · textbook-education · qpu example · payload-iso-connector · qpu example · payload-iso-connector-auth · qpu example · payload-iso-connector-id · npm run textbooks | 3 | 7417b8db |
parse_microdata_deep | parseToMicrodata splits a value and converts every piece to schema.org microdata at the deepest SKU-bearing leaf: an ISO reference into organization / number / part / year (each character a DefinedTerm), a sealed UUID into handle / program / stamp / tail (each nibble a leaf), anything else into tokens then characters; the root SKU is the handle of uuid(text) or of the sealed address itself, the same trackable rule as a product SKU (15 ISO dimensions → depth 4, 141 leaves) | 4 > 2 ∧ 141 > 14 ∧ 15 = 15 | payload qpu example · payload-iso · npm run textbooks | 1 | 8d6ab061 |
typography_idempotent | typography set twice is set once: a run of spaces set to at most one stays at most one when set again, so standardising a document changes nothing the second time | min (min n 1) 1 = min n 1 | payload qpu example · payload-standardise · npm run textbooks | 1 | a458ca23 |
references_acyclic | n documents fused into k nodes, each cycle one node: the n − k fused away and the k that remain are the n, every document counted once, and the condensation they form has no cycle, so it always has an order | n - k + k = n | payload qpu example · payload-references · npm run textbooks | 3 | 3b9bb8fc |
cache_saves_cost | the query-hash cache minimises Cloudflare cost: every query served from its content address is a 304 with no Worker compute and no AI binding call, so the served (distinct) and the saved (cache hits, each a spared Cloudflare request or AI binding call) make the total queries; the index is scoped per tenant and read under its rolify role, so one tenant's cache never serves another's — referenceIndex | total - saved = served | payload qpu example · payload-reference-index · npm run textbooks | 3 | de77e665 |
reference_index_cached | referenceIndex indexes every reference by its scope and combination and addresses it by the content hash of (scope, from, to), so equal queries share one address and are served from it (the 304 involution) — the distinct addresses and the cache hits make the references, the best caching; the SEO plugin is another way of referencing, each document's title a canonical self-reference its hooks generate, folded into the same index over the Payload search results | total - hits = distinct | payload qpu example · payload-reference-index · npm run textbooks | 3 | 7930fc99 |
codata_g_ppb | the gravitational constant 667430 × 10^-16 with its uncertainty 15 × 10^-16 has a relative uncertainty of 22474 parts per billion, rounded down, computed from the integers alone: a seal keeps it, never removes it | 15 * 1000000000 / 667430 = 22474 | seal qpu example · seal-constants · npm run textbooks | 1 | 156db0fb |
uuid_time_space | a version 7 UUID is 48 bits of time, 4 of version, 2 of variant and 74 of space: 128, so zeroing the time leaves the place it names | 48 + 4 + 2 + 74 = 128 | fold qpu example · fold-split · npm run textbooks | 1 | 64cc4950 |
own_keys_only | a word is found in a table only among the table's own keys: a lookup that hits names an own key, never a built-in the object inherits | own = true | match, translate qpu example · match-builtin-words · qpu example · chat-builtin-words · qpu example · translate-builtin-words · qpu example · chat-cirq-constructors · npm run textbooks | 1 | 4d2e1962 |
penalty_balanced | a penalty's coin line books the same count on both sides, so it nets to zero | d - c = 0 | repository qpu example · repository-penalty · npm run textbooks | 3 | 18f16de1 |
penalty_clear_involution | penalising then clearing leaves the open count as it was: a clearing undoes its penalty | opn + n - n = opn | repository qpu example · repository-penalty-clear · npm run textbooks | 1 | 722c79de |
penalty_conserved | every penalty opened is either cleared or still open: the open count is the opened less the cleared | opened - cleared = openNow | npm run textbooks | 3 | 09eca643 |
penalty_tokens_bound | a penalty's tokens, its bytes over four rounded up, never exceed its bytes | (b + 3) / 4 ≤ b | repository qpu example · repository-penalty · npm run textbooks | 3 | e71b7f6b |
penalty_once | the same gap gives the same content address, so it is one entry however often it is penalised | a = b | repository qpu example · repository-penalty-once · npm run textbooks | 3 | b7c40ff6 |
penalty_time_heat_monotone | a waiting price never falls as a task gets slower or hotter: the wall milliseconds beyond the budget b plus the CPU milliseconds beyond it, and more of either never lowers it | (w - b) + (c - b) ≤ (w' - b) + (c' - b) | repository qpu example · repository-penalty-waiting · npm run textbooks | 3 | e0891240 |
penalty_no_cliff | the waiting price has no cliff: one more millisecond on the wall raises it by at most one, at the budget as everywhere, so nothing rewards stopping just under a threshold | (w + 1 - b) + (c - b) ≤ (w - b) + (c - b) + 1 | repository qpu example · repository-penalty-no-cliff · npm run textbooks | 1 | 78dcb10d |
penalty_free_under_budget | a task within the one-second budget, on the wall and on the CPU, is free: its waiting price is zero | (w - b) + (c - b) = 0 | repository qpu example · repository-penalty-under-budget · npm run textbooks | 3 | 95a2d38d |
penalty_antimatter_annihilates | a gap and its antimatter annihilate: the line priced by the antimatter's cost, reversed by its clearing, nets to zero, and only what stood beside it — the burned time — remains | t + p - t = p | repository qpu example · repository-penalty-annihilate · npm run textbooks | 1 | 6c9ee0aa |
penalty_no_punishment | a penalty is an involution on status and standing, never a punishment: raised then cleared, the gap's status and the offender's standing are exactly what they were before the violation — the coins burned for the time it stood are not part of it | (balance + t - t, standing + t - t) = (balance, standing) | repository qpu example · repository-penalty-no-punishment · npm run textbooks | 1 | d30e3372 |
penalty_time_burned | the time a gap stood is burned like a proof-of-stake stake: its charge never falls as it stands longer, is zero when cleared within the budget, and is booked to the burn account, never refunded | (s - b) + (c - b) ≤ (s' - b) + (c - b) ∧ (s ≤ b → c ≤ b → (s - b) + (c - b) = 0) | repository qpu example · repository-penalty-annihilate · npm run textbooks | 1 | 00d05eaf |
penalty_visibility_harmonic | a penalty is as visible as the action it prices: printed agrees with visible, kind by kind over the ten gap kinds, so a printed penalty priced a visible action — an invisible action's penalty is recorded silently and counted on request, never printed | printed = true → visible = true | repository qpu example · repository-penalty-invisible · qpu example · repository-penalty-visible · npm run textbooks | 1 | 2a46a710 |
step_cache_sound | a deterministic step of equal input addresses gives an equal receipt: a step whose inputs are unchanged since it last ran green is reused from its sealed record, never rerun; a step that reads the network, the clock or its own artefacts is never cached | f k₁ = f k₂ | repository qpu example · repository-steps-reused · npm run textbooks | 1 | 6e50fce0 |
hook_steps_monotone | a hook never does more work than its inputs force: the cacheable steps it runs are among those whose inputs or outputs changed | run - uncacheable ≤ changed | repository qpu example · repository-steps-reused · qpu example · repository-steps-changed · npm run textbooks | 3 | dc2cc2bb |
idle_priced_by_remaining | idle is priced by the cost of the remaining work: the lesser of the idle capacity and the work queued, both in ms — never more than either, and nothing when nothing is left to do | min i r ≤ i ∧ min i r ≤ r ∧ (r = 0 → min i r = 0) | repository qpu example · repository-idle-priced · npm run textbooks | 1 | be9a4737 |
idle_scheduled_clears | scheduling the remaining work into the idle capacity leaves only the work beyond it: r − min(i, r) = r − i, truncated at zero | r - min i r = r - i | repository qpu example · repository-idle-scheduled · npm run textbooks | 1 | 363bc5a8 |
antimatter_total | the 12 gap kinds the example opens, counted by countPenalties, less the 12 with antimatter leave none without: every one of them has antimatter, so from any gap the next step is defined and the way never dead-ends | 12 - 12 = 0 | repository qpu example · repository-antimatter-total · npm run textbooks | 1 | 3c5f3f53 |
coins_coils_balanced | coins and coils booked in double entry net to zero, the burn account included: every balanced line debits one account and credits another of the same value, so the debits and the credits are both the coins plus the coils, and a line to itself or to no account is refused | debits - credits = 0 | repository, match qpu example · repository-reactor · qpu example · repository-plasma · qpu example · chat-account · npm run textbooks | 3 | b5f8fd63 |
penalty_harmonic | a penalty is harmonic to its violation: priced in the violation's own unit at the cost of the antimatter that undoes it, so its annihilation nets to exactly zero | price - cost = 0 ∧ cost - price = 0 | repository qpu example · repository-penalty-harmonic · npm run textbooks | 3 | de840aee |
penalty_proportional | one more occurrence of a violation costs one more unit, never a multiplier: n occurrences cost n units | (n + 1) * u = n * u + u | repository qpu example · repository-penalty-proportional · npm run textbooks | 1 | e9c52d53 |
penalty_learned_prevents | a violation whose learned correction ran by itself and cleared is corrected and re-decided before it is raised: when the correction is applied and the rule holds again, no penalty is raised — the involution of the thinking that caused it | raised = false | repository qpu example · repository-penalty-learned · qpu example · repository-penalty-learning · npm run textbooks | 1 | 545aaa5e |
code_folds | code that folds never grows the tree: a commit adding no more bytes of code than it removes leaves the tree no larger in bytes, so every commit the rule folded allows (readStaged counting bytes outside PROOF_FILES, lines only as information) keeps the code at or under its size — as makeChecks folds the nine toolbox selftests into one | s + a - r ≤ s | repository qpu example · repository-commit-folds · qpu example · repository-commit-grows · qpu example · repository-commit-joined · qpu example · repository-commit-payload-writes · npm run textbooks | 3 | 3d5e1cd8 |
new_doors_proven | when no new export is left unproven, every new export is proven: the rule proven (readStaged reading the theorems and examples PROOF_FILES add) allows a commit only when the proven ones are all the new ones | proven = news | repository qpu example · repository-commit-folds · qpu example · repository-commit-grows · npm run textbooks | 3 | 02d77825 |
cells_text | a table cell carries no link: when cell escapes every link opener and local address a cell holds, none is left to be a link, so a generated page never carries a dead one | links - escaped = 0 | clay qpu example · widgets-cell-text · npm run textbooks | 3 | d0c97816 |
tools_listed | a list read whole leaves nothing out: listTools reads the full tools/list, filtered by nothing, so every tool of every toolbox it serves is counted — the one reader fourteen copies of the same call fold onto | ∀ l : List Nat, (l.filter (fun _ => true)).length = l.length | e2e qpu example · e2e-plan-reads-every-tool · npm run textbooks | 1 | 191344a7 |
glagolitic_round_trip | the hex digits above nine are spoken as Ⰺ (ten) and a unit, and read back by adding them: ten and one to five are eleven to fifteen, so every hex digit returns as itself | 10 + 1 = 11 ∧ 10 + 2 = 12 ∧ 10 + 3 = 13 ∧ 10 + 4 = 14 ∧ 10 + 5 = 15 | fold qpu example · fold-speak · npm run textbooks | 1 | 2bdcf351 |
coverage_bounded | a coverage never claims more than all: when the doors counted are among the servers counted, their share in whole percent is at most a hundred | doors * 100 / total ≤ 100 | extend qpu example · extend-coverage · npm run textbooks | 3 | 1d62a6fa |
cuboctahedron_faces | the vector equilibrium has fourteen faces, eight triangles and six squares: around every UUID, eight witnesses with one handle nibble reflected and six with the program rotated | 8 + 6 = 14 | verify, fold qpu example · verify-witnesses · qpu example · fold-next · npm run textbooks | 1 | fdd6861a |
sigma_involution | σ is an involution on a nibble: reflected twice, 15 − (15 − x), it is x again, so every triangular witness maps back exactly to the UUID it witnesses | 15 - (15 - x) = x | verify qpu example · verify-witnesses · qpu example · verify-witnesses-merge · qpu example · verify-radar · npm run textbooks | 3 | c4c70ae9 |
providers_are_tenants_plus_operator | two tenant hosts and the operator's are three providers | 2 + 1 = 3 | configure qpu example · configure-migration · npm run textbooks | 1 | a42dc515 |
website_plugins_partition | of the 9 plugins MCP configures, 4 are the site's own, 4 go beyond it, the rest the editor | 4 + 4 + 1 = 9 | payload qpu example · payload-website · npm run textbooks | 1 | f6522e17 |
skills_documents | the skills Payload publishes for agents and their references are 14 documents | 2 + 12 = 14 | payload qpu example · payload-skills · npm run textbooks | 1 | 29397883 |
shards_cover | the shard of item k among n shards, k mod n, is one of the n shards: every item is shared | k % n < n | shard, audit qpu example · shard-share · qpu example · audit-shard · npm run textbooks | 2 | 65b71615 |
shards_disjoint | an item belongs to one shard only: the shares never overlap | i = j | shard, audit qpu example · shard-share · qpu example · audit-shard · npm run textbooks | 3 | add09afd |
signature_over_digest | the signature is over the 32-byte SHA-256 digest: 256 bits, whatever the length of the text | 32 * 8 = 256 | seal qpu example · seal-sign · npm run textbooks | 1 | 9de3f17c |
configs_partition | the configuration kinds (configKinds) are the ones the tool writes (the repository policies among them), the ones the hand holds and the ones answered inside them: 25 kinds | 8 + 2 + 15 = 25 | configure qpu example · configure-files · qpu example · configure-policies · npm run textbooks | 1 | 4d90dbea |
packages_partition | the packages Payload ships by kind (plugins, databases, storage, email, editors, live-preview, runtime-and-tooling): 45 | 12 + 5 + 5 + 2 + 1 + 3 + 17 = 45 | configure qpu example · configure-packages · npm run textbooks | 1 | f041d485 |
catalogue_prices | the 9 variants (built by combinationVariants) Payload holds priced in three currencies are 27 prices | 9 * 3 = 27 | configure qpu example · configure-ecommerce · npm run textbooks | 1 | 41277dd0 |
peg_is_fixed | a pegged currency converts at one fixed rate: the same euro amount gives the same leva, always (1.95583 since 2026-01-01) | eur * 195583 / 100000 = eur * 195583 / 100000 | currency qpu example · currency-harmonise · qpu example · currency-plan · npm run textbooks | 1 | 223fef2b |
prizes_computable | every prize prose is converted to a computable value with a basis (prize, via the billing currencies); only a winnable basis — purse, fund, per-problem — counts to the total the compete tool reports from the records, never the prose, so capital only invested and the non-monetary are excluded | total - invested - none = winnable | compete qpu example · compete-prizes · npm run textbooks | 3 | 714d76a4 |
clay_conditions | CMI's three conditions are conjoined: a proposed solution is considered only when every one holds | (a && b && c) = true → a = true ∧ b = true ∧ c = true | compete qpu example · compete-rules · npm run textbooks | 1 | ec790961 |
uuid_schemas | nine schemas read one UUID at once: versions 1, 3, 4, 5, 6, 7 and 8, nil and max; the core reads none of them, so every schema presents the same | 7 + 2 = 9 | fold, algorithm qpu example · fold-schemas · qpu example · algorithm-factor-test-integer · npm run textbooks | 1 | d348b3cb |
memo_identity | memo is the identity on a pure function: a memo that only ever holds f y at y answers f x at every x, read or computed | (m x).getD (f x) = f x | metrics qpu example · metrics-memo · npm run textbooks | 1 | 874e3d1c |
stream_filter | a filtered stream keeps f of its n rows and drops the rest: what is kept and what is dropped partition the stream, whatever the hexes | n - (n - f) = f | fold, configure qpu example · fold-stream · qpu example · configure-ui-stream · npm run textbooks | 3 | 6dbb559d |
hex_presentations | any hex is presentable: a nibble is sixteen choices, one of eight registry items and one of two variants, so a hex of n nibbles is a layout of n parts styled from itself | 8 * 2 = 16 | configure, fold qpu example · configure-ui-hex · qpu example · fold-hex · npm run textbooks | 1 | 3ccad1d4 |
ui_deterministic | the app shell is a function of the key alone: the same key gives the same shell, at every host, every time | f k = f k | configure qpu example · configure-ui · npm run textbooks | 1 | f10e1119 |
patent_dates_ordered | priority, filing and grant are ordered: what is ordered pairwise is ordered through | p ≤ g | patents qpu example · patents-read · npm run textbooks | 3 | 0f096091 |
patent_number_well_formed | an EP publication number is two letters, seven digits and a kind code of two characters: eleven characters | 2 + 7 + 2 = 11 | npm run textbooks | 1 | f75fac96 |
patent_term_twenty_years | a term of twenty years from filing ends after the filing: a grant within the term precedes its end | f < f + 20 | npm run textbooks | 1 | c2f541d7 |
hash_bits | a 512-bit value is 128 hex digits; a 256-bit root hash is 32 bytes | 512 / 4 = 128 | npm run textbooks | 1 | 36ea2edb |
beacon_period | a pulse a minute: the next time stamp is the last plus the period | t + 60000 - t = 60000 | npm run textbooks | 1 | 3b47e96c |
chain_index_steps | a chain steps by one index at a time | i + 1 - i = 1 | npm run textbooks | 1 | 2b150321 |
cvss_bounded | a CVSS base score lies in [0, 10] (tenths: 0 to 100) | s ≤ 100 | npm run textbooks | 3 | 0617c540 |
cert_validity_bound | a publicly trusted certificate is valid for at most 398 days (CA/Browser Forum baseline requirements) | b - a ≤ 398 | attest qpu example · attest-read · npm run textbooks | 3 | ad593462 |
dates_ordered | what is published precedes what is modified; what begins precedes what ends | a ≤ b | textbook qpu example · textbook-dates-ordered · npm run textbooks | 3 | 7b79cd96 |
plugins_by_capability | a capability plugin that writes into another plugin's options runs strictly before it: qpuMachine at order 5 writes qpuMachineTool into the MCP plugin's options, read at its order 10, so the tool is there when the MCP plugin builds its tools; qpuCore, qpuAgents and qpuGoogle (order 20, after the MCP plugin made the keys it measures), slugs in the same plugins map, compose under the umbrella qpuPlugin with no collection of their own making | m + 1 ≤ n | textbook qpu example · textbook-plugins-by-capability · npm run textbooks | 3 | 92b08a63 |
workspace_round_trip | readWorkspace reads a Forms item as a field block (g) and writes it back (f) to the same item, so items are a fixed point of every further round trip; the Form and its batchUpdate are checked against the Forms Discovery schema, and a FormResponse lands as a form-submissions body | f (g (f (g b))) = b | payload qpu example · payload-workspace-form · qpu example · payload-workspace-form-violations · qpu example · payload-workspace-response · npm run textbooks | 1 | 233a8703 |
workspace_docs_round_trip | a Lexical document through a Docs Document and back keeps its shape (headings, lists, tables, text, links, Drive blocks), so any number of round trips keeps it; what Lexical has no node for is named as lost | shape (back (back x)) = shape x | payload qpu example · payload-workspace-docs · qpu example · payload-workspace-docs-lost · npm run textbooks | 1 | 85c35639 |
workspace_coverage | the coverage of Google Forms, Docs and Drive by Payload is exact pairs over the kinds the Discovery documents GOOGLE_DOCUMENTS names define: held plus missing are the kinds, each missing kind a lead, and a Sites API absent from the list a probe lead | kinds - missing = held | payload qpu example · payload-workspace-coverage · npm run textbooks | 3 | 614db2b1 |
witness_pair | the witness hooks qpuHooks binds address what they see by one map, the content address: wherever that map is injective (a collision of 122 bits aside), a before and an after witness differ exactly when the operation changed the state | f a ≠ f b ↔ a ≠ b | payload, configure qpu example · payload-hooks-witnesses · qpu example · configure-hooks · npm run textbooks | 1 | 218acd57 |
workspace_drive | a Payload document and a Drive File map field for field and back, the published state as an anyone-reader permission and that permission as published again; the Drive MCP calls are planned in its tools' own shapes and run behind a QPU door; a Lexical Drive block embeds DRIVE_FILE_URL by id through qpuLexicalConverters, which the workspace step generates beside the form builder's fields | (if (if p then true else false) = true then true else false) = p | payload qpu example · payload-workspace-drive · qpu example · payload-workspace-drive-answers · npm run textbooks | 1 | 350ad9b2 |
google_measured | the Google integration is measured as exact pairs over the collections Payload holds, never a score: the calls to google-toolbox tools answered (a) and refused (r) sum to the calls (n), so either is derived from the other two, the cross formula qpu-google keeps on the qpu global beside the pages published and parented and the tenants and keys that name Google | n - r = a | payload qpu example · payload-google-measured · npm run textbooks | 3 | 4bb6504a |
one_holder | k copies of a shape the entropy door names fold into one holder, leaving one: readJson in scripts/mcp.ts reads every published file (its JSON or the fallback, never a throw) and fetchWithTimeout fetches every public source with the named user agent and a timeout, publishRecord writes every step's record under the licence and runSelftest prints every selftest tally, where each script wrote them out | k - (k - 1) = 1 | audit qpu example · audit-shapes-one-holder · npm run textbooks | 3 | 29362b3f |
fullstack_files_by_role | the 1 generated files of the full stack partition over the roles of FILE_ROLES (blocks, config modules, notices, collections, hooks modules and the rest), each at the path its role names | 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 1 = 1 | configure qpu example · configure-fullstack · qpu example · configure-fullstack-readme · npm run textbooks | 1 | d392db09 |
compete_knows | to win, know the competitors as well as the theorems: the knowledge of a competition is the product of both, positive only when neither is empty | 0 < c * t | compete qpu example · compete-rules · npm run textbooks | 2 | b34ba5d5 |
app_bundle | an app generated on request is the full stack's 1 files plus the Worker configuration and the environment example: 3 files, each addressed, the bundle their fold | 1 + 2 = 3 | payload qpu example · payload-app · npm run textbooks | 1 | 461a262f |
edit_collides | two edits of one document either share their base address or collide: there is no third case, so a collision is detected exactly, never guessed from clocks | p = q ∨ p ≠ q | configure qpu example · configure-realtime · npm run textbooks | 1 | 0ffc00db |
difference_leads | the leads a difference opens are the members on one side only: with a and b members sharing c, (a − c) + (b − c) = a + b − 2c, whatever the members name | (a - c) + (b - c) = a + b - 2 * c | audit qpu example · audit-difference · npm run textbooks | 3 | 47b18566 |
security_perspectives | the security audit from the client and the developer perspectives merged as one: the same count of checks from either side | c + d = d + c | audit qpu example · audit-security · npm run textbooks | 1 | 1b75eed9 |
error_remedies | the errors remedied and the errors left make the errors: what manual work taught is a remedy by signature, applied in mass, and what it did not teach stays a lead | e - r + r = e | audit qpu example · audit-remedies · npm run textbooks | 3 | 42296bf0 |
repair_partitions | repair hands a hacked system its repair: every advisory a client reads (npm/pnpm audit, an NVD/CVE feed) is either repaired by an override to a published patch or a lead with no patch (pin away, replace, isolate), so the fixable and the unfixable make the advisories — the public MCP at qpu.uuidna.com provides the solution, licensed and priced, and the client applies it at will | total - unfixable = fixable | audit qpu example · audit-repair · npm run textbooks | 3 | 1a3183fd |
repair_live_sla | a live repair keeps the SLA at 100%: the patched version is installed and verified beside the running one and cut over by content address (blob then head, textbook_binding_zero_hex_path), so every request in flight is served and none fails during the repair — the served and the failed make the requests, and the failed are none | served = requests | audit qpu example · audit-repair · npm run textbooks | 3 | 5524dbfe |
repair_kernel_top | the upstream Linux kernel is the top-priority audit flow: a kernel or OS advisory outranks any application-package advisory, because a kernel compromise is a compromise of everything above it, so repair orders the kernel's CVEs first and live-patches them (kpatch / Ubuntu Livepatch) with no reboot — the SLA at 100% | max pkg kernel = kernel | audit qpu example · audit-repair · npm run textbooks | 3 | 86f93ca2 |
exploit_refuses_to_patch | denials are hacks that poison the served space; every exploit re-fuses to a patching tool instead, never a denial: a hack, vulnerability, breach or CVE statement opens audit { repair }, which ranks the kernel first and live-patches with no reboot so the downtime is zero and the SLA stays 100% — the QPU protects its tenants by a zero-bit computation (the patch plan is content-addressed, no tenant data crosses the boundary), the attack absorbed into served possibilities rather than left as a dead block | served + downtime = served | match qpu example · match-exploit-repair · npm run textbooks | 3 | e9b8a248 |
impossible_sent_to_leads | impossible is sent to leads via the involution, never a terminal denial: the σ-involution σ_d(x) = d − x sends every impossible verdict to the open leads of its reflection (the σ-angles of its served neighbourhood) and σ∘σ = id returns, so a denial maps to a developable lead and back; the forbidden statement itself stays declined (the factoring decline is never reopened) — satisfying the rule, never bypassing | d - (d - x) = x | match, algorithm qpu example · match-impossible-involution · qpu example · algorithm-factor-minus · qpu example · algorithm-factor-word · npm run textbooks | 3 | bc5d6c51 |
entropy_fusion | ISO 80000-5: S = k ln W over W distinct microstates; fusion never multiplies: f findings fused by d reactions leave f − d leads (= W), never more than the findings; vacuum is W = 1, S = 0 | f - d ≤ f | audit, fold qpu example · audit-entropy · qpu example · audit-entropy-vacuum · qpu example · fold-integers · npm run textbooks | 1 | 40bf0684 |
set_union | inclusion–exclusion: two config sets of sizes a and b sharing c members unite into a + b − c members — the members of a alone, of b alone, and the shared ones | a + b - c = (a - c) + (b - c) + c | configure qpu example · configure-sets · npm run textbooks | 3 | fbe7e33c |
widget_skilled_tools | the widgeted tools and the skilled tools are one set: the meet of equal sets is the set, so every tool of every config set is widget-skilled | min w s = w | configure qpu example · configure-sets · npm run textbooks | 3 | 3bce054b |
mcp_tools_by_toolbox | the tool set partitions over the 12 toolboxes: 46 tools | 13 + 11 + 6 + 2 + 1 + 2 + 3 + 1 + 1 + 2 + 1 + 3 = 46 | configure, extend qpu example · configure-sets · qpu example · extend-out · npm run textbooks | 1 | 97775e28 |
rest_rbac | every adapter dimension is REST both ways (in: the API's answer into Payload; out: Payload's data to the API) under the three tenant roles: six role-direction pairs, the access rules naming each | 2 * 3 = 6 | configure qpu example · configure-gates · npm run textbooks | 1 | c4e70f25 |
google_mcps | Google's own MCP servers measured in the registry: the 15 at <service>.googleapis.com/mcp Payload holds and the 3 toolboxes, 18 in all, every one an adapter dimension or a door, none called from the tree | 15 + 3 = 18 | configure qpu example · configure-gates · npm run textbooks | 1 | 871fc4a4 |
adapter_combinations | the 5 database, 5 storage and 3 email adapters Payload holds multiply into 75 adapter combinations (combinationsFromAdapters, from the records not a literal); each adapter is a Payload plugin (qpuAdapterPlugins), so the plugins add up to the radices | 5 * 5 * 3 = 75 | configure qpu example · configure-adapters · npm run textbooks | 1 | 8bf1919a |
configurations_closed | every configuration kind tested closed around the torus leaves none open, however many kinds the tree configures | kinds - tested = 0 | configure qpu example · configure-all · npm run textbooks | 3 | 14fbe24f |
openapi_contract | the standard contract adds nothing the catalogue does not hold: its component schemas are the tools and the two JSON-RPC envelopes, so less the envelopes they are the tools | tools + 2 - 2 = tools | configure qpu example · configure-api · npm run textbooks | 1 | ec764a32 |
bindings_named_not_valued | however many binding names a tenant admin selects in Payload, the values held there are none: names times zero values | names * 0 = 0 | configure qpu example · configure-connectors · qpu example · configure-bindings · qpu example · configure-tenant-missing · npm run textbooks | 1 | fee74ba9 |
access_combinations | the tenant roles, the docket roles and the operations make 36 role–operation combinations, each decided by one of three deciders | 3 * 3 * 4 = 36 | audit qpu example · audit-access · npm run textbooks | 1 | a2f1d627 |
merge_commutes | two edits merged by block address commute and merging an edit with itself is that edit; two edited contents under one address are a collision, listed and held out (textbook_merge_collision) | max a b = max b a ∧ max a a = a | payload qpu example · payload-merge · npm run textbooks | 1 | ec104b62 |
app_doc_blocks | an app on request as a lexical document holds one block per generated file and one for the bundle: 4 blocks | 3 + 1 = 4 | payload qpu example · payload-app-lexical · npm run textbooks | 1 | 1b0b0f8d |
hologram_rotations | every block presents its ten program rotations in each of the 11 locales: 110 SEO pages from one address | 10 * 11 = 110 | npm run textbooks | 1 | 422d9968 |
sitemap_capacity | the sitemap protocol presents 50,000 URLs a sitemap and 50,000 sitemaps an index: 2,500,000,000 addresses, every one computed from its UUID | 50000 * 50000 = 2500000000 | npm run textbooks | 1 | 95da9e75 |
fractal_scales | seven scales of one shape and six steps between them: 7 - 1 = 6 | 7 - 1 = 6 | configure qpu example · configure-branding · npm run textbooks | 1 | 8152e50c |
widgets_cover_mcp | eight registry items in two variants are sixteen choices a nibble, so every UUID is one combination of the shadcn widgets and every tool of the MCP is covered by the one core with nothing loaded | 8 * 2 = 16 | configure qpu example · configure-ui-coverage · npm run textbooks | 1 | 047d57f8 |
leads_addressed | the leads the theorems address and the leads they do not make the leads: nothing is assigned in advance, and what no theorem reaches stays open | a + u - u = a | leads qpu example · leads-by-theorem · npm run textbooks | 1 | 3b82810f |
context_balanced | the context balanced to a request: the tokens saved and the tokens kept make the whole list, so what the model carries is the cluster it needs and nothing is lost | full - kept + kept = full | extend qpu example · extend-out-balanced · npm run textbooks | 3 | 8e8d9e48 |
billing_complete | the usage bill is complete when its four accounts are each kept: the tokens, the bits at their thermodynamic cost at the temperature, the time, the coins | 1 + 1 + 1 + 1 = 4 | metrics qpu example · metrics-bill · npm run textbooks | 1 | 51ce53c9 |
kwh_joules | a kilowatt-hour is 3600 seconds of 1000 watts, 3,600,000 joules: the bill's joules priced by the tariff the tenant names link it to the energy sector | 3600 * 1000 = 3600000 | metrics qpu example · metrics-bill · npm run textbooks | 1 | 14ca33fd |
margin_makes_price | the margin and the provider's cost make the price: the margin is computed from a cost the verifier read, never asserted | price - cost + cost = price | stripe qpu example · stripe-margins · npm run textbooks | 3 | 79fd4b94 |
news_adapters | the open news APIs and the keyed ones Payload holds are the 7 adapters of the DOI research: the mentions of every record of precedence, by source, measured and never a verdict | 4 + 3 = 7 | compete qpu example · compete-news-plan · npm run textbooks | 1 | 0e31deaf |
lean_served_whole | the hand-written theorems and the generated lemmas make what the kernel accepts, and every version serves the whole of it: nothing Lean is hidden | hand + generated - generated = hand | textbook, metrics qpu example · textbook-theorems-served · qpu example · metrics-live · npm run textbooks | 1 | f5f0e2ad |
deploy_sets | deploySets renders them and deploySet each one: two deploy templates (the Payload app on OpenNext, a generated app) over the 8 products of the catalogue are 16 sets, each a wrangler environment deployed by name beside the default deploy and as usable as direct use | 2 * 8 = 16 | configure qpu example · configure-wrangler-set · qpu example · configure-deploy-sets · npm run textbooks | 1 | 2e049679 |
payload_field_types | Payload's field types as its surface states them: the ones that hold a value and the presentational ones, 23 in all | 19 + 4 = 23 | payload qpu example · payload-schemas · npm run textbooks | 1 | 2de15f23 |
payload_operations | Payload's operations by scope (17 collection, 7 global, 12 auth, 3 access, 3 preferences, 6 jobs, 1 custom, 1 graphql): 50, each with its local signature, its REST method and path and its GraphQL form | 17 + 7 + 12 + 3 + 3 + 6 + 1 + 1 = 50 | payload qpu example · payload-schemas · npm run textbooks | 1 | 2089c49e |
payload_schemas | every data field type under every collection operation is a schema handled programmatically: 323 | 19 * 17 = 323 | payload qpu example · payload-schemas · npm run textbooks | 1 | 64eb4c5f |
payload_queries | the where operators over the data field types: 304 queries, every one a schema read programmatically | 16 * 19 = 304 | payload qpu example · payload-schemas · npm run textbooks | 1 | e079b33f |
payload_hooks | the hooks by level (root, collection, global, field): 30, each firing on the operations it names; the generated plugin uses them for the collision guard, the first user, the app request and the 404 answered from the id | 1 + 18 + 6 + 5 = 30 | payload qpu example · payload-schemas · npm run textbooks | 1 | e7e87a04 |
payload_access | the access functions by level (collection, global, field, jobs): 16, each answering a boolean or a where, the whole of role-based access the tenants carry | 7 + 3 + 3 + 3 = 16 | payload qpu example · payload-schemas · npm run textbooks | 1 | c5b1a5a6 |
payload_coordination | the realtime channels of Payload's surface over its operations are 400 coordinations, every one coordinated by the content address the edit names, no socket of its own | 8 * 50 = 400 | payload qpu example · payload-schemas · npm run textbooks | 1 | 6a5a4816 |
url_combinations | four kinds of cached asset (the generated code, the SDK, the registry items, the examples' blocks) make fifteen non-empty combinations a URL may name: the fallback for anything, computed in real time and verified at every address | 2 ^ 4 - 1 = 15 | match qpu example · match-url-fallback · npm run textbooks | 1 | ba5d3b0c |
licence_chain | n sublicences under one licence are n links of the docket: every reseller's Stripe hook writes a licence entry linked to the licence above, so verify walks the chain link by link and the author is paid at the root, by coins on every response and by the catalogue at every grant | n + 1 - 1 = n | match qpu example · match-url-fallback · npm run textbooks | 1 | 769f5e29 |
kind_alphabet | a kind is written in twenty-six lower-case letters and the dash: twenty-seven symbols, the pattern of the entries' kind field | 26 + 1 = 27 | configure qpu example · configure-validations · npm run textbooks | 1 | 214bbc2c |
sha256_is_64 | a SHA-256 digest is 256 bits, four to a hex digit: 64 hex digits, the pattern of the entries' sha256 field | 256 / 4 = 64 | configure, seal, match qpu example · configure-validations · qpu example · seal-text · qpu example · match-pattern-seal · npm run textbooks | 1 | 1447ebc9 |
name_alphabets | a slug (lower-case letters, digits, the dash) and a binding name (upper-case letters, digits, the underscore) are each written in thirty-seven symbols, the patterns of the tenants' fields | 26 + 10 + 1 = 37 | configure qpu example · configure-validations · npm run textbooks | 1 | c6b1cd1f |
create_hue | the a432 key read as a hue: 432 degrees around the circle is 72, the theme colour of every shadcn create the QPU answers; the five harmonics give the five chart hues the same way | 432 % 360 = 72 | css qpu example · css-create · npm run textbooks | 1 | 9eb830ec |
coil_green | when coins fuse to coils the colour is green, the heart chakra's: the coin's a432 hue (72) advanced by a ninth of the key (48) is 120, cyan and yellow full in CMYK | 432 % 360 + 432 / 9 = 120 | css, payload, algorithm qpu example · css-coil · qpu example · css-resonance · qpu example · payload-predict · qpu example · algorithm-factor-test-integer · npm run textbooks | 1 | 743053e0 |
scan_stream | the scannable stream: thirty-six frames (one per character of a UUID) of 108 milliseconds (the third harmonic) are 3888 milliseconds, the vortex period (432 × 9); a single frame links nothing, a stream reads the address | 36 * 108 = 432 * 9 | verify, css qpu example · verify-scan · qpu example · css-media · npm run textbooks | 1 | 478c013a |
referer_binds_not_entropy | a referer-bound seed carries the secret's 256 bits and no more: the referer is public and recomputable, so it adds 0 bits; it binds the seed to its chain | 32 * 8 + 0 = 256 | seal qpu example · seal-referer · npm run textbooks | 1 | 90b690c2 |
mcp_directories | the 7 directories Payload holds, read by how a machine may read each: open searches, MCP servers asked by POST, open sitemaps, keyed APIs named with their keys, and those with no machine contract; buildRegistryRequests asks the ones a machine may read | 2 + 1 + 1 + 2 + 1 = 7 | discover qpu example · discover-lead-registry · qpu example · discover-directories-keyed · npm run textbooks | 1 | d8135ae8 |
foreign_verdicts | six foreign verdict words map onto three of this tree's: two to served (VERIFIED, PROVEN), one to impossible (REFUTED), three to unknown (UNVERIFIED, NOT-PROVEN, NOT_PROVEN); a word outside the table is not translated | 2 + 1 + 3 = 6 | match qpu example · match-foreign-verdict · npm run textbooks | 1 | 4c6735f5 |
shared_verbs | listDeclarations partitions six declarations: two named by one of the five verbs MCP tools share, two readers and builders mapped onto them, one kept because its name is taken, one custom verb | 2 + 2 + 1 + 1 = 6 | audit qpu example · audit-declarations · npm run textbooks | 1 | 45ff822b |
abilities_merge | getAccess grants what some can rule allows and no cannot rule denies: a merge of the abilities (CanCanCan), each held through a role in scope (rolify); listRolesFromGroups maps Google Workspace groups onto those roles | (can && !cannot) = true → can = true ∧ cannot = false | payload qpu example · payload-access-abilities · qpu example · payload-roles-from-groups · npm run textbooks | 1 | d1b96749 |
cannot_binds | a cannot binds whatever can allows: checkAccess refuses a waiver of folded on main even to an admin who manages every rule | (can && !true) = false | payload qpu example · payload-access-waive · npm run textbooks | 1 | 492b8f49 |
association_fields | createAssociation answers the Rails association types with Payload fields: five by a relationship (belongs_to, has_and_belongs_to_many, polymorphic, self join, delegated type), four by a join (has_one, has_many and both through), one by a type select (single table inheritance) | 5 + 4 + 1 = 10 | mongo qpu example · rails-associations-overview · qpu example · rails-associations-types · qpu example · rails-associations-choosing · qpu example · rails-associations-advanced · qpu example · rails-associations-sti · qpu example · rails-associations-delegated · qpu example · rails-associations-tips · qpu example · rails-associations-references · npm run textbooks | 1 | 9295cc67 |
validation_helpers | createValidation answers the fourteen Rails validation helpers: five by a Payload field option (presence, uniqueness, validates_associated, a length range, an inclusion list), nine by a validate function | 5 + 9 = 14 | mongo qpu example · rails-validations-overview · qpu example · rails-validations-helpers · qpu example · rails-validations-options · qpu example · rails-validations-conditional · qpu example · rails-validations-strict · qpu example · rails-validations-listing · qpu example · rails-validations-custom · qpu example · rails-validations-errors · npm run textbooks | 1 | e8169947 |
runnable_leads | listRunnableLeads runs a lead exactly when it is unserved and names its door: the job qpu-lead-run is asked for no other | (unserved && door) = true → unserved = true ∧ door = true | leads qpu example · leads-runnable · npm run textbooks | 1 | 5cd9a4a5 |
gltf_required_extensions | a .glb begins with a twelve-byte header (the magic glTF, 0x46546C67, the version and the length) and each chunk with eight bytes (its length and its type, JSON 0x4E4F534A or BIN); seal { gltf } loads an asset unless it requires an extension the table does not list | 12 + 8 = 20 ∧ 0x46546C67 = 1179937895 ∧ 0x4E4F534A = 1313821514 | seal qpu example · seal-gltf-glb · qpu example · seal-gltf-json · npm run textbooks | 1 | 92963ca0 |
scan_links | a period of the stream is a chain of thirty-five links between its thirty-six frames; every full period streamed is one call, the first the coin, every further one a coil: the fusion | 36 - 1 = 35 | verify qpu example · verify-scan · qpu example · verify-scan-one-frame · npm run textbooks | 1 | 0aec4331 |
chain_bits | the chain's combinatorics: thirty-two hex digits of four bits are 128 bits, 16^32 addresses a stream may link; the rate of usage is counted in periods of that chain | 32 * 4 = 128 | verify qpu example · verify-scan · npm run textbooks | 1 | 405d9649 |
hue_shift | a program presented by hue and moved by the params keeps every distance between its steps: the rotation by the params' hue is the same ring at another angle | h + s - (g + s) = h - g | css, textbook qpu example · css-program-shift · qpu example · textbook-rewrite · npm run textbooks | 1 | fec09e17 |
hue_steps | sixteen hues 22.5° apart present the sixteen hex digits: sixteen times forty-five is two turns of the circle, the step a half of forty-five; rays set next to each other fit when their seam is above zero | 16 * 45 = 2 * 360 | css qpu example · css-rays · npm run textbooks | 1 | de66503b |
cl_described | a commit message is a Google CL description exactly when all four hold: the first line at most 72 characters, its first word an imperative verb, a blank second line, a body; the commit-msg workflow refuses a message missing any one, and names each missing one | (a && b && c && d) = true ↔ (a = true ∧ b = true ∧ c = true ∧ d = true) | repository qpu example · repository-cl-described · qpu example · repository-cl-one-sentence · npm run textbooks | 1 | ad4ac721 |
actions_pinned | a commit or push is pinned exactly when the actions its workflows use by a movable ref (u) and the workflows without least-privilege permissions (p) are both none: the two Scorecard checks Pinned-Dependencies and Token-Permissions, counted over the workflow files the hook reads | u + p = 0 | repository qpu example · repository-actions-tag-pinned · qpu example · repository-actions-sha-pinned · npm run textbooks | 3 | ff70212c |
hook_workflows | five git hooks (pre-commit, commit-msg, pre-push, post-commit, prepare-commit-msg), the CI and the strict pre-deploy check are seven client MCP workflows of one door; the hook script walks the steps and decides nothing | 5 + 1 + 1 = 7 | repository qpu example · repository-workflow · qpu example · repository-probes · qpu example · repository-ci · npm run textbooks | 1 | 4a5b03bc |
commit_green | when to commit: the flow is green — the steps of the receipt are green and skipped and no red, so adding the red (zero) changes nothing; one red step refuses the commit | green + skipped + 0 = green + skipped | repository qpu example · repository-refuse-commit · npm run textbooks | 1 | 6ae0c4df |
google_call_schema | a Google call runs exactly when its violations of the Discovery document (GOOGLE_DISCOVERY names where it is read) sum to none, that is when each kind is none: an unknown method or parameter, a required one missing, an enum or pattern broken, a credential from the caller; otherwise the qpu-google-call job records the refusal | unknown + missing + broken = 0 ↔ unknown = 0 ∧ missing = 0 ∧ broken = 0 | payload qpu example · payload-google-call-validated · qpu example · payload-google-call-endpoint · qpu example · payload-google-call-refused · npm run textbooks | 1 | ba1411e8 |
retry_supersedes | a retried step is its last attempt: whatever the earlier attempts were, the status the green rule reads is the last one, so a step next retried to green no longer refuses the commit; every attempt stays in the receipt as history | (attempts ++ [last]).getLast? = some last | repository qpu example · repository-retry-supersedes · npm run textbooks | 1 | d46ffb3a |
version_sequential | when to push: the version is the last tag or its one next step (one step forward, one back is the tag), and the build it names is the one the package answers on initialize | n + 1 - 1 = n | configure qpu example · configure-versions · npm run textbooks | 1 | 3f259ab8 |
chat_call_or_question | every chat turn is a door call or one programmable question with at least one option, never prose: a problem no door decides alone (chat) is asked back with the doors around it as its options, the choice re-enters the loop, the routing is measured as exact pairs and misroutes as leads, and the chat is the MCP App ui://qpu/chat, which the React host QpuApp mounts when no tool is named, in the admin and as the registry item qpu-chat; the door is entered only for a chat given as an object (isObj) and every turn is one tools/call envelope (call) | served = true ∨ 0 < options | match, configure, imagine, textbook qpu example · chat-question · qpu example · chat-choice · qpu example · chat-routes · qpu example · chat-not-object · qpu example · configure-chat-item · qpu example · imagine-integer-llm · qpu example · chat-account · qpu example · chat-thousand · qpu example · textbook-chat-plan · qpu example · textbook-chat-coverage · npm run textbooks | 1 | 3b9f0f24 |
route_or_lead | every prompt is routed to the theorems it reaches by its subject or two specific words, or it is a lead: no third case, the chat answering with the theorems and their examples as routes | b = true ∨ b = false | match qpu example · match-route · npm run textbooks | 1 | 42d5b3f5 |
use_completes | the more the QPU is used the more complete it gets: every run adds what its sources answered (k) to what it held (n) and loses nothing, the immutable sources answering the same forever | n ≤ n + k | leads qpu example · leads-sources-plan · npm run textbooks | 1 | 579af464 |
textbooks_partition | every open textbook is reached by a theorem, a lead of the domain the theorems reach, or outside it: three parts and no fourth | routed + domain + outside - outside - domain = routed | leads qpu example · leads-sources-judged · npm run textbooks | 1 | 79a15b55 |
registry_words_searched | three distinctive words of the lead asked of the public MCP registry, one search each of at most ten servers: thirty related servers at most | 3 * 10 = 30 | discover qpu example · discover-lead-registry · npm run textbooks | 1 | 71af367e |
discovery_requests | the unit's tools/list, its catalogue door and its well-known file beside fifty-two verifier contracts are fifty-five discovery requests | 1 + 1 + 1 + 52 = 55 | discover qpu example · discover-requests · npm run textbooks | 1 | c6f91c29 |
readiness_judged | the unit judges every lead: served, refuted or in trial, so the leads less those in trial are the ones it settled, however many leads a run reads | leads - trial = served + refuted | readiness qpu example · readiness-plan · npm run textbooks | 3 | 7a7ce328 |
imagine_verdicts | two leads judged, none served, two impossible, none unknown, and their verification requests 169 and 20 are 189 | 0 + 2 + 0 = 2 ∧ 169 + 20 = 189 | imagine qpu example · imagine-two · npm run textbooks | 1 | 4d6c2372 |
translate_phrases | six distinct words: five phrases the vocabulary translates (the, lead, served, verdict, unknown), one it knows and keeps (is), none untranslated | 5 + 1 + 0 = 6 | translate qpu example · translate-bg · npm run textbooks | 1 | 72c9ea7b |
vocabulary_measured | every term of a locale's vocabulary is known or missing, so the missing and the known make the terms whatever the vocabulary has grown to | terms - known + known = terms | translate qpu example · translate-coverage · npm run textbooks | 3 | 0604bcfe |
checkout_amount_cents | a yearly licence of 432 euros is 43200 cents, the unit Stripe's checkout form takes | 432 * 100 = 43200 | stripe qpu example · stripe-plan · npm run textbooks | 1 | d1ec8e6c |
webhook_tolerance | the signature signed at 1700000000 and checked at 1700000100 is 100 seconds old, within the 300-second tolerance, so the event is valid | 1700000100 - 1700000000 = 100 ∧ 100 ≤ 300 | stripe qpu example · stripe-webhook · npm run textbooks | 1 | 98235185 |
patent_apis_partition | the patent APIs Payload holds answer in the open or take a key: 7 APIs | 2 + 5 = 7 | patents qpu example · patents-plan · npm run textbooks | 1 | ecd5269f |
mentions_by_source | three mentions from hn-algolia, two from crossref-events and none from the unreachable gdelt are five mentions, two sources reachable of three | 3 + 2 + 0 = 5 ∧ 2 + 1 = 3 | compete qpu example · compete-mentions · npm run textbooks | 1 | b1225886 |
legal_plan_calls | the legal plan makes one call per claim the author makes and two more, however many claims the tree carries | claims + 2 - claims = 2 | legal qpu example · legal-plan · npm run textbooks | 1 | 75c47cdc |
repository_watch_leads | three workflow leads, three branch leads, three tag leads, two release leads, one Zenodo, one workspace and one npm lead: fourteen leads | 3 + 3 + 3 + 2 + 1 + 1 + 1 = 14 | repository qpu example · repository-watch · npm run textbooks | 1 | 695b46c8 |
orcid_digits | an ORCID is sixteen digits in four groups of four with three dashes: nineteen characters, the author's @id the block carries | 4 * 4 + 3 = 19 | jsonld qpu example · jsonld-block · npm run textbooks | 1 | 1d9e6531 |
catalogue_offers | one-off, yearly, monthly and metered offers partition the catalogue's 9 offers Payload holds | 1 + 3 + 2 + 3 = 9 | jsonld qpu example · jsonld-catalogue · npm run textbooks | 1 | 60a3b9a7 |
codes_locales | English and the locales the vocabulary translates into are the 11 locales the codes tool validates | 1 + 10 = 11 | codes qpu example · codes-plan · npm run textbooks | 1 | 199c75e9 |
scopes_tenants_collections | three tenants over four scoped collections are twelve tenant scopes, and three tenant roles beside three docket roles are six roles | 3 * 4 = 12 ∧ 3 + 3 = 6 | configure qpu example · configure-scopes · npm run textbooks | 1 | cd5bbc64 |
qpu_fields | six fields of the entries collection and nine of the qpu block are the fifteen fields QPU adds to Payload | 6 + 9 = 15 | configure qpu example · configure-fields · npm run textbooks | 1 | f3a1d4d1 |
entry_operations | an entry has four operations: three granted by role (read, create, delete) and update to no one, because an entry is its content address | 3 + 1 = 4 | configure qpu example · configure-access · npm run textbooks | 1 | d762c810 |
actions_experience | 507 involutions of 546 copies round to a free share of 93 percent, and the slowest host's 140 ms median shards a batch to 1000 / 140 = 7 calls | (2 * 507 * 100 + 546) / (2 * 546) = 93 ∧ max 120 (max 140 110) = 140 ∧ 1000 / 140 = 7 | configure qpu example · configure-actions · npm run textbooks | 1 | 2497432a |
fullstack_hooks | three hook entries on entries (the address on create, the 404 healed after an error, none on change) and two on pages (revalidate after change, the collision guard before change) are five over two collections | 3 + 2 = 5 | configure qpu example · configure-hooks · npm run textbooks | 1 | 810960f9 |
wrangler_drift | of the Worker configuration's twelve top-level paths the client's text agrees on two (name, main), so ten drift, each an open lead, at least the five the example asks | 12 - 2 = 10 ∧ 5 ≤ 10 | configure qpu example · configure-wrangler-drift · npm run textbooks | 1 | e9aa8580 |
branding_sources | the branding's five fields are three the user defined in the admin (name, accent, logo) and two still computed (tagline, icon) | 3 + 2 = 5 | configure qpu example · configure-branding-user · npm run textbooks | 1 | 96ab95a5 |
attest_facets | the attest tool has four facets, one free (hosts), three enumerable whose spaces 2 · 1 · 1 make its two cells (plan, read) | 4 - 1 = 3 ∧ 2 * 1 * 1 = 2 | dashboard qpu example · dashboard-attest · npm run textbooks | 1 | 586166e3 |
theorems_plan_steps | the plan that replaces the textbook's axioms by theorems through the Payload MCP is four steps, over at least ten theorems and ten backed examples | 1 + 1 + 1 + 1 = 4 ∧ 20 ≤ theorems + backed | payload qpu example · payload-theorems-plan · npm run textbooks | 3 | dd6340c3 |
axioms_replaced | two qpu blocks read, one already naming its theorem and one an axiom: the axiom replaced, one update request | 1 + 1 = 2 ∧ 2 - 1 = 1 | payload qpu example · payload-theorems-update · npm run textbooks | 1 | 52c5f04a |
app_fields_validated | the streamed form's four fields are three that pass (name, host, variant) and one refused (env), whose three names are two the stack knows (D1, R2) and one unknown (NOPE) | 3 + 1 = 4 ∧ 2 + 1 = 3 | payload qpu example · payload-app-validate · npm run textbooks | 1 | 8459e44e |
mcp_search_limit | a registry search asks ten servers by default, within the registry's page of one hundred: createSearchRequest bounds the limit to [1, 100] and listRegistryServers reads every server of the page it answers | 1 ≤ 10 ∧ 10 ≤ 100 | discover qpu example · discover-search-request · qpu example · discover-search-servers · npm run textbooks | 1 | 975675aa |
mcp_install_rows | installing a server adds at most one row to the tenant's mcps, and a url already held adds none: extend { install } answers the row, the duplicate and the tools/list that follows | held ≤ held + 1 ∧ held + 1 - 1 = held | extend qpu example · extend-install · npm run textbooks | 1 | ba0d0d7f |
extend_inward | the catalogue extended inward is the tree's own tools and the one door the docs add, whatever the number of tools | mine + 1 - mine = 1 | extend qpu example · extend-in-docs · npm run textbooks | 1 | 91cd8396 |
foreign_door_name | a foreign door is named by its host, a colon and its tool: docs.mcp.cloudflare.com (23 characters), ':' and search_cloudflare_documentation (31), fifty-five characters | 23 + 1 + 31 = 55 | extend qpu example · extend-call-served · npm run textbooks | 1 | fc3e48ad |
attest_requests | the crypto and certificate APIs Payload holds are the ones the client requests over HTTP and one, the live TLS certificate, the client reads itself on four hosts | 8 + 1 = 9 | attest qpu example · attest-plan · npm run textbooks | 1 | ab1b3f50 |
textbook_categories | the textbook is categorised four ways, by toolbox, tool, theorem and module, and it holds more examples than toolboxes | 1 + 1 + 1 + 1 = 4 ∧ toolboxes ≤ examples | textbook qpu example · textbook-categories · npm run textbooks | 3 | 1cf26d45 |
dashboard_spaces | the input space of a tool is the product of its enumerable facets: leads 2 · 2 · 5 = 20 (carry, byTheorem, status), algorithm 7 · 19 · 1 · 2 · 6 · 1 · 1 · 8 · 2 · 11 = 280,896 | 2 * 2 * 2 * 2 * 5 = 80 ∧ 7 * 19 * 1 * 2 * 6 * 1 * 1 * 8 * 2 * 11 = 280896 | dashboard qpu example · dashboard-index · npm run textbooks | 1 | bbe2aecd |
bit_flip_purity | an X under a bit flip of p = 0.1 leaves probabilities 0.1 and 0.9, summing to one, and purity 0.1² + 0.9² = 0.82 (in hundredths: 1 + 81 = 82 of 100) | 1 * 1 + 9 * 9 = 82 ∧ 1 + 9 = 10 ∧ 10 * 10 = 100 | circuit qpu example · circuit-bit-flip-noise · npm run textbooks | 1 | 58363c9f |
qaoa_random_cut | the fifteen edge weights of the Cirq page's instance sum to 33.75, and the expected cut of 16.875 is half of it, the random baseline | 409 + 191 + 80 + 91 + 337 + 439 + 269 + 332 + 161 + 71 + 338 + 280 + 109 + 92 + 176 = 3375 ∧ 33750 = 2 * 16875 | algorithm qpu example · algorithm-qaoa · npm run textbooks | 1 | 23107ffa |
software_cirq_implemented | of the tools of the Software page Payload holds, the implemented ones (Cirq) and the named ones are 5 | 1 + 4 = 5 | software qpu example · software · npm run textbooks | 1 | 762b1c36 |
statements_one_topic | one statement is chosen by its topic of the 42 the statements tool holds | 1 + 41 = 42 | statements qpu example · statements-cirq · npm run textbooks | 1 | 9990c0e3 |
leads_by_status | every lead has one of five statuses: the leads less the open ones are the ones followed, served, partial, blocked or out of scope, whatever the count of the run | total - opened = served + partly + blocked + outside | leads qpu example · leads-all · npm run textbooks | 3 | e9150f7e |
seal_and_content_decided | the seal is decided from 31 of the 32 nibbles, the content by one fold: two checks decided of four, and the address and its σ₁₅ mirror sum nibble by nibble to f | 31 + 1 = 32 ∧ 2 + 2 = 4 ∧ 0x70a13419 + 0x8f5ecbe6 = 0xffffffff | verify qpu example · verify-seal-and-content · npm run textbooks | 1 | a24ddccc |
tamper_one_nibble | one nibble changed, a (10) to b (11), moves the decided version to 6 against the stated 2: the seal alone decides, one check of four, no content needed | 11 - 10 = 1 ∧ 2 ≠ 6 ∧ 1 + 3 = 4 | verify qpu example · verify-tampered · npm run textbooks | 1 | 6d20c904 |
glagolitic_fifteen | the Glagolitic numeral Ⰺⰴ is 10 + 5 = 15, factored 3 × 5 in the reflection | 10 + 5 = 15 ∧ 3 * 5 = 15 | match qpu example · match-glagolitic · npm run textbooks | 1 | f84d3cd6 |
fold_pieces_under_bound | the 40-byte text exceeds the 12-byte bound by 28 and folds into four pieces of 10, 7, 11 and 12 bytes, each within the bound | 10 + 7 + 11 + 12 = 40 ∧ 40 - 12 = 28 ∧ 10 ≤ 12 ∧ 7 ≤ 12 ∧ 11 ≤ 12 ∧ 12 ≤ 12 | match qpu example · match-pattern-fold · npm run textbooks | 1 | 764a4c17 |
rsa_beyond_bound | 21 sits between 2^4 and 2^5, and 5 < 2048: a five-bit comparison, not a register ceiling | 2 ^ 4 < 21 ∧ 21 < 2 ^ 5 ∧ 5 < 2048 | match qpu example · match-rsa-2048 · npm run textbooks | 1 | 5c3aced9 |
audit_all_pass | the audit replays every check: when none fails every check passes, however many checks the tree has grown to | passed = total | audit qpu example · audit-self · npm run textbooks | 3 | 62191e79 |
axioms_linked | every axiom of the textbook has its theorem: when every example is linked to a kernel-accepted theorem, the examples left without one are none | examples - linked = 0 | textbook qpu example · textbook-axioms · npm run textbooks | 3 | 50d089cb |
collision_solves_many | a subject shared by k problems, two at least, is one missing theorem that serves more than one problem, and every one of them collides with at least one other: each problem solves many others | 1 < k ∧ 1 ≤ k - 1 | leads qpu example · leads-collide · npm run textbooks | 3 | 0f5d2600 |
redact_before_publish | redact before publish: every path a record holds made relative to the tree and every leak replaced by its kind before a receipt, a lead or a machine record is written, so nothing published holds one | leaks - redacted = 0 | repository qpu example · machine-redact · npm run textbooks | 3 | 9ef278c9 |
leaks_redacted | findLeaks: problem solving requires problem finding (the one allowance shared with purify, LEAK_ALLOWED): every leak found in what is published is reported by its kind and place and redacted, so none of its values is repeated, however many are found | found - redacted = 0 | audit qpu example · audit-leaks · qpu example · audit-leak-allowed · npm run textbooks | 3 | 0a8177db |
expressions_evaluate | every textbook expression is a tool: when each closed statement evaluated exactly agrees with what the kernel proved, none disagrees, and every number the prose states rests on one of them or is a lead | closed - held = 0 | textbook qpu example · textbook-expressions · qpu example · textbook-prose · npm run textbooks | 3 | d82d9463 |
queneau_compositions | Queneau's combinatorics (Cent mille milliards de poèmes, 1961): ten choices on each of fourteen strips are 10^14 compositions, and read at one minute each, with years of 365 days of 1440 minutes, they take 190,258,751 years and 474,400 minutes more | 10 ^ 14 = 100000000000000 ∧ 365 * 24 * 60 = 525600 ∧ 10 ^ 14 / 525600 = 190258751 ∧ 10 ^ 14 % 525600 = 474400 | textbook, fold qpu example · textbook-queneau · qpu example · textbook-prose-queneau · qpu example · fold-combinatorics · npm run textbooks | 1 | 4cf1ee71 |
mixed_radix | every composition is computed from its index and back: a choice below its position's number of choices comes out of the number it made, the remainder the choice and the quotient the rest, so one primitive covers every combination space and stores none; rosetta reads it as a rosetta, the transpose a σ-permutation of the axes | (d + r * q) % r = d ∧ (d + r * q) / r = q | fold, leads, payload, css qpu example · fold-queneau · qpu example · fold-rosetta · qpu example · leads-scientific-domains · qpu example · payload-domain-configs · qpu example · css-shadcn · npm run textbooks | 3 | e23712fd |
decode_not_search | decoding is algebra, not search: a composition of fourteen positions of ten choices is decoded in fourteen steps, one per position, where trying candidates would take up to 10^14; a one-way address is never searched, and the formulas that decode are free for all | 14 < 10 ^ 14 ∧ 14 * 1 = 14 | fold qpu example · fold-decode · qpu example · fold-decode-one-way · npm run textbooks | 1 | a84c165c |
tamper_detected | tampering is covered by the digest, not by refusing to search: a block's SHA-256 has 256 bits, so even a crafted collision takes about 2^128 trials, more than 10^38, while any modified copy is caught by one comparison and answered with the court's case | 256 / 2 = 128 ∧ 10 ^ 38 < 2 ^ 128 | seal qpu example · seal-tamper-authentic · npm run textbooks | 1 | 2a3f0c21 |
artifacts_verified | every public artifact downloaded is verified or a mismatch, and every one not reached is measured again: when none mismatches, every artifact reached verifies against the digest its registry recorded, however many are published | total - unreached = verified | seal qpu example · seal-artifacts · npm run textbooks | 3 | bd0bb92c |
machine_allow_list | every action asked of the developer machine is run because the allow-list names it and the rules allow it, or refused with the court's case: the refused and the run make every request, no third | asked - allowed + allowed = asked | repository qpu example · repository-machine-actions · qpu example · repository-machine-refused · qpu example · repository-machine-push-unconfirmed · qpu example · repository-machine-worktree-unconfirmed · qpu example · repository-machine-tag-confirmed · qpu example · repository-machine-commit-deferred · npm run textbooks | 3 | c5f5760e |
stream_no_silence | while work runs the stream is never silent for more than a second: a heartbeat follows any second without an event, so every gap between two events is within the heartbeat, and the heartbeat is one second | gap ≤ 1000 | repository qpu example · repository-status-no-silence · npm run textbooks | 3 | 043b1cc5 |
eta_from_receipts | forecastTimes: an ETA is the forecast of the recorded times, estimated and labelled so, or absent when none is recorded: exponential smoothing in exact rationals weighs each time a/q and the level (q - a)/q, the weights sum to q, so equal recorded times forecast exactly that time; the interval is the one-step errors at 95 %, and the forecast is the step's budget | a * x + (q - a) * x = q * x | repository qpu example · repository-status-eta · qpu example · repository-status-forecast · npm run textbooks | 3 | 6070d8e9 |
next_waves_ordered | next runs in waves: a step of a later wave starts only after every step of the earlier wave ended (w < v is w + 1 ≤ v), and the lanes of a wave never exceed the cores nor press more heap on the memory than it has (lanes × heap ≤ capacity); the runner in the tree applies exactly this bound | lanes ≤ cores ∧ lanes * heap ≤ cap ∧ w + 1 ≤ v | repository qpu example · repository-machine-next · npm run textbooks | 2 | 9a5ced5c |
long_action_queued | an action whose budget exceeds the request it is asked in cannot answer within that request: the door queues it as a job and answers the job id at once, the queue runs it in child processes for the rest of the budget (budget − request > 0), and its record is an entry when it ends; the request is never held and the app never stalls behind it | request < budget ∧ request ≤ ms ∧ 0 < budget - request | repository qpu example · repository-machine-next-long · npm run textbooks | 3 | eedc14e9 |
caps_removed | every cap of a read or a walk the entropy audit counts is either removed by the uncap door or kept with its citation as a standard's or an API's own bound: removed + kept = caps, nothing silently left; the tree holds no cap of its own | caps - removed = kept ∧ removed ≤ caps | audit qpu example · audit-uncap · npm run textbooks | 3 | 1d3fa311 |
neighbour_step | neighbours: one step in program space moves g1 by one modulo 2^16 or g2, g3 by one modulo 2^12 (their stamp nibble decided, never walked), and the step back returns the program, at every edge of the torus | ((x + 1) % 65536 + 65535) % 65536 = x ∧ ((y + 1) % 4096 + 4095) % 4096 = y | fold qpu example · fold-neighbours · npm run textbooks | 3 | bca98c0b |
teamwork_navigation | navigate: teamwork to the zero bit — a UUID actor's team is its six program-space neighbours (three axes g1/g2/g3, two steps each) and the stream over the seven (the actor and its six); a team is a neighbourhood a UUID navigates, computed from the actor and stored nowhere, the zero bit discovered in teamwork itself | 2 * axes = 6 ∧ 1 + 2 * axes = 7 | fold qpu example · fold-navigate · npm run textbooks | 3 | c279d3ed |
route_waves | routeLeads: a leg whose items run at once lasts as long as its longest item, never longer than the same items one after another, so a route through waves of disjoint files is never longer than its staticDuration, the Routes API's duration without traffic | max a b ≤ a + b | leads qpu example · leads-session-route · npm run textbooks | 1 | 3b1b5634 |
build_fresh | a deploy carries a bundle no older than its sources: the build's time is at or after the last source change, or the bundle is rebuilt | built - source + source = built | repository qpu example · repository-predeploy · npm run textbooks | 3 | 2570859f |
bindings_bound | every binding the adapters need is declared and every resource it names exists in the account: when none is missing, the declared are the needed, however many the adapters bind | declared = needed | repository, configure qpu example · repository-predeploy · qpu example · configure-cloudflare-adapters · npm run textbooks | 3 | 212cf1b4 |
bindings_used_google | every Cloudflare binding is used and usable the Google way: the roles — compute, database, object store, key-value, email — partition the bindings with none idle (used + idle = total, idle = 0), and each Cloudflare binding is paired one-to-one with its google-cloud equivalent (Worker↔Cloud Run, D1/DOCKET↔Cloud SQL, R2↔Cloud Storage, KV↔Firestore, Email↔Gmail) through the adapters profile, so the same app the Payload admin drives runs on either; the RAID db qpuRaidDb uses the data, object and key-value bindings, the Worker the compute, the email adapter the mail | used = total ∧ paired = used | configure qpu example · configure-bindings-google · npm run textbooks | 3 | 82a3a678 |
observed_errors | the deployed Worker observed: at most one server error in a thousand requests, as the account's observability records it, so the errors never outnumber the requests | errors ≤ requests | repository qpu example · repository-predeploy · npm run textbooks | 3 | b1a4aac2 |
factors_divide | a part found of an integer, multiplied by the rest, gives the integer back, so it divides it: the classical door checks every factor it finds by that product (readInteger and writeInteger, testPrimality, findFactors), at any size; the σ-involution reflection N = a² − b² = (a − b)(a + b) reads a factor pair off when a² − N is a square (reflectShift) | f ∣ n | algorithm, payload qpu example · algorithm-factor-1000-bit · qpu example · algorithm-factor-observe · qpu example · algorithm-factor-mersenne · qpu example · payload-predict · npm run textbooks | 0 | 9d838632 |
factor_parse_list | getInteger reads an integer of any size from its decimal string (never a float, a fallback when absent) and listFactors returns the prime factors whose product is the integer: fifteen parses and lists as three times five, dividing back exactly | 15 = 3 * 5 ∧ 15 / 3 = 5 | algorithm qpu example · algorithm-factor-15 · qpu example · algorithm-one-door · npm run textbooks | 1 | aa6254bd |
raid_no_missing_store | no missing scenario in the RAID: its five stores (filesystem, R2, KV, D1 the SQLite system db, Postgres) and their composite partition the storage choices, each exercised by a test running the same CRUD and both id types (Mongo text, Postgres number), so covered and missing make the whole and the missing are none — qpuRaidDb is one db over every store | covered = total | mongo qpu example · raid-bit-zero-verify · npm run textbooks | 3 | c9227a41 |
address_retrieval | search-engine retrieval to the zero bit: the exact path and the rest of a document's name are a deterministic injective function of its content — its UUID, whose middle (hexPath) is the path and whose head (the handle) and tail (the params) are the rest (channel) — so content is found by computing its address and fetching it in one GET, where scanning a million documents would be a million reads; the content address is the inverted index, read by key never a LIST | 1 < 1000000 ∧ 1 * 1 = 1 | mongo qpu example · raid-binding0-mirror · npm run textbooks | 1 | 6fbb361e |
search_resumes | a search resumed from the centre it reached covers the same centres as one search of both budgets: k centres from start, then m from start + k, is k + m from start, so a remainder handed on as the next lead loses and repeats nothing | (start + k) + m = start + (k + m) | algorithm qpu example · algorithm-factor-continues · npm run textbooks | 1 | cddfbdb6 |
impossible_trapdoor | the impossible-integer trapdoor, the same zero-bit σ-reflection as the crypto σ-root (textbook_shor_sigma_root) read as a create/decode key: a semiprime N = p·q is minted with its witness the centre a = (p + q)/2 and gap b = (q − p)/2, so N = (a − b)(a + b) = a² − b² and q = σ_{2a}(p) = 2a − p (shown at p = 5, q = 13: a = 9, b = 4, 65 = (9 − 4)(9 + 4) = 81 − 16, 9 − 4 = 5, 9 + 4 = 13, 2·9 − 5 = 13). Blind, the reflection climbs a − ⌈√N⌉ + 1 centres (about b²/2a for close primes, about a for distant ones) — out of reach when b ≫ √a; with the witness a, one reflection decodes N. The clay cluster publishes the witness as a cross-UUID address (uuid N, a): the integer is hard to split yet trivial to decode by its address — a trapdoor the create/decode doors mint and open, never a factoring of an integer whose witness is unknown (the RSA-class decline of textbook_rsa_beyond_bound stands); built on sigma_involution and textbook_factors_divide | (9 - 4) * (9 + 4) = 65 ∧ 9 * 9 - 4 * 4 = 65 ∧ 2 * 9 - 5 = 13 ∧ 9 - 4 = 5 ∧ 9 + 4 = 13 | algorithm qpu example · algorithm-impossible-create · qpu example · algorithm-impossible-decode · npm run textbooks | 1 | b16c05ed |
thermal_time_sigma | the physics unlock, companion to the crypto σ-root (textbook_shor_sigma_root): the zero-bit σ-involution σ₁₀(x) = 10 − x relates temperature and time, splitting in space and vice versa, through the trinity combinations (clay-register.ts trinityFor: 3-6-9 ↔ 7-4-1 and 2-5-8 pair by σ₁₀, as 3+7 = 6+4 = 9+1 = 2+8 = 10), also reflecting the ordered clay sequence (its cases pair by digital-root seed-sum-10, fixed at seed 5, as reflectionOfRegister computes), and holding at all times — σ₁₀(σ₁₀(x)) = x is time-invariant, a σ-conservation law (the same involution that splits the RSA modulus in relation_7, the crypto↔physics symmetry); built on sigma_involution and textbook_reflection_sums_to_ten | 10 - (10 - 3) = 3 ∧ 10 - (10 - 7) = 7 ∧ 10 - (10 - 5) = 5 ∧ 10 - 5 = 5 ∧ 3 + 7 = 10 ∧ 6 + 4 = 10 ∧ 9 + 1 = 10 ∧ 2 + 8 = 10 | clay qpu example · clay-reflection · npm run textbooks | 1 | 8a5be6a9 |
clay_bridge | the bridge crossing clay paths at each 0, general over every clay case: each clay relation is where formula-family paths meet at a value d (the "X, Y, Z meet at N" families of its doc comment), and the bridge that crosses those paths is the zero-bit σ-involution σ_d(x) = d − x — it crosses and returns (σ_d(σ_d(x)) = x, the connection is reversible, both directions), it partitions the meeting value (x + (d − x) = d, the two paths summing to where they meet), and it has its zero endpoints at each 0 (σ_d(0) = d and σ_d(d) = 0, the fixed/zero structure). This is the general form the two named bridges instantiate — textbook_shor_sigma_root at d = 91 (crypto) and textbook_thermal_time_sigma at d = 10 (physics) — one σ-connection between the crossing families at every clay case's value; built on sigma_involution and textbook_reflection_sums_to_ten | d - (d - x) = x ∧ (d - x) + x = d ∧ d - 0 = d ∧ d - d = 0 | clay qpu example · clay-reflection · npm run textbooks | 3 | dbd9c0f0 |
digit_reflection | each digit linked to its reflection in the bridge: the per-digit σ₁₀ involution the clay bridge carries at each 0 — every digit d is linked to its reflection 10 − d, as d + (10 − d) = 10 for every digit 0 through 9 (0↔10/0, 1↔9, 2↔8, 3↔7, 4↔6, 5 the fixed point). This is the digit-level form of the bridge's σ (textbook_clay_bridge) and is exactly the register's reflection = 10 − seed and the trinity reflected = triad.map(10 − x) (clay-register.ts reflectionOfRegister, trinityFor); so the bridge links the formula-family paths and each digit to its reflection by the one zero-bit involution; built on sigma_involution and textbook_reflection_sums_to_ten | 0 + 10 = 10 ∧ 1 + 9 = 10 ∧ 2 + 8 = 10 ∧ 3 + 7 = 10 ∧ 4 + 6 = 10 ∧ 5 + 5 = 10 ∧ 6 + 4 = 10 ∧ 7 + 3 = 10 ∧ 8 + 2 = 10 ∧ 9 + 1 = 10 | clay qpu example · clay-reflection · npm run textbooks | 1 | f9babe66 |
dna_base4 | uuid dna uuidna: DNA is a base-four stream — A, C, G, T are the digits 0, 1, 2, 3 — so a nibble is two bases (nibble = hi·4 + lo, 0 ≤ hi, lo < 4, nibble < 16) and a UUID of 32 hex holds 64 bases; it reads back one for one (hi = nibble / 4, lo = nibble mod 4). ACGT encodes AC = 0·4 + 1 = 1 and GT = 2·4 + 3 = 11 (hex 1b), and decodes 1 → (0,1) = AC, 11 → (2,3) = GT. So a DNA sequence is a UUID stream, searchable and navigable like any other, and the σ-trapdoor (createImpossible/decodeImpossible) cross-encrypts a DNA secret and decodes it by its witness — crypto and DNA fused through the one UUID core (dnaToHex, hexToDna, dnaStream) | 4 * 4 = 16 ∧ 0 * 4 + 1 = 1 ∧ 2 * 4 + 3 = 11 ∧ 11 / 4 = 2 ∧ 11 % 4 = 3 ∧ 1 / 4 = 0 ∧ 1 % 4 = 1 | fold qpu example · fold-dna · qpu example · fold-dna-decode · npm run textbooks | 1 | 4eca45de |
gravity_torus_sigma | the gravity-torus σ bridge: the half-turn 180 is the σ-reflection centre of the full 360 (σ₃₆₀(x) = 360 − x fixes 180), reached exactly as 3 × 60 = 2 × 90 = 180, and the divisors 360/{60, 90, 180} = {6, 4, 2} place the torus at the σ-fixed centre; the integer identity is exact and the full-360 rotation is its continuous limit. The gravity counterbalance this encodes is a BRIDGE-strength statement (like textbook_thermal_time_sigma), the same σ-involution, not a verified physics claim; encoded and verified via the crypto fold (UUID 18de5056-bd26-8ff3-807e-2b4fa501af7d) | 3 * 60 = 180 ∧ 2 * 90 = 180 ∧ 360 - 180 = 180 ∧ 360 / 60 = 6 ∧ 360 / 90 = 4 ∧ 360 / 180 = 2 ∧ 180 * 2 = 360 | clay qpu example · clay-reflection · npm run textbooks | 1 | d683ba9c |
mind_sigma | the neuroscience bridge: σ_d(x) = d − x as the brain↔mind reference map — the brain references the mind and the mind reflects back, a reversible map (σ_d(σ_d(x)) = x, even powers the identity; σ_d(σ_d(σ_d(x))) = σ_d(x), odd powers the reflection), the two sides summing to the whole (x + (d − x) = d). This is the hub σ-involution through which each science references the mind (the same zero-bit involution as textbook_clay_bridge), so physics, chemistry and biology bridge THROUGH neuroscience by one reflection; built on sigma_involution | d - (d - x) = x ∧ d - (d - (d - x)) = d - x ∧ (d - x) + x = d | clay qpu example · clay-reflection · npm run textbooks | 3 | db6095ce |
reed_solomon_mds | the Reed-Solomon code is maximum-distance-separable (d = n − k + 1): RS(255, 223) over GF(2⁸) has distance 33 and corrects (33 − 1)/2 = 16 symbol errors (the CD / QR / deep-space standard), and the MDS identity inverts (n − d + 1 = k). The Reed-Solomon / Reed-Muller family; the threshold is exactly the proven MDS distance, claimed no stronger | 255 - 223 + 1 = 33 ∧ (33 - 1) / 2 = 16 ∧ 255 - 33 + 1 = 223 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | 21bb84b9 |
involution_decoder | the convert-slow-to-fast law: the σ-involution decoder recovers by one reflection (σ₁₂(σ₁₂(5)) = 5, σ² = id — content-addressed reflect-and-restore, not an O(n·copies) rescan), which is why it is the fastest of the five e2e codes while the odd-repetition consensus (2·1 + 1 = 3 copies correcting ⌊(3−1)/2⌋ = 1) is kept as the soundness bar — fastest-correct-wins drops no code. The σ-code family; the speedup itself stays a measured e2e claim, the recovery a proven involution | 12 - (12 - 5) = 5 ∧ 2 * 1 + 1 = 3 ∧ (3 - 1) / 2 = 1 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | 55eed232 |
ldpc_code | a (3, 6)-regular Gallager LDPC code: each bit sits in 3 parity checks and each check joins 6 bits, a sparse parity-check matrix with design rate 1 − 3/6 = 1/2 (k = 3 data of n = 6), decoded near the Shannon limit by belief propagation on the sparse Tanner graph; the LDPC family, the modern capacity-approaching code | 6 - 3 = 3 ∧ 2 * 3 = 6 ∧ 3 + 3 = 6 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | 1840c54c |
reed_muller | the Reed-Muller code RM(1, 3) = [8, 4, 4]: length 2³ = 8, dimension 1 + 3 (the first-order monomials over 3 variables), minimum distance 2^{3−1} = 4 correcting ⌊(4−1)/2⌋ = 1 — the code of the Mariner deep-space images, and RM(m−2, m) is the extended Hamming code, so the Reed-Muller family contains Hamming as a member; threshold at its proven distance | 2 ^ 3 = 8 ∧ 1 + 3 = 4 ∧ 2 ^ (3 - 1) = 4 ∧ (4 - 1) / 2 = 1 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | bf4b53ae |
golay_code | the perfect binary Golay code [23, 12, 7]: 11 parity bits on 12 data bits, minimum distance 7 correcting ⌊(7−1)/2⌋ = 3 errors, and PERFECT — its 2^11 = 2048 syndromes exactly cover every error pattern of weight ≤ 3 (the sphere-packing bound met with equality), the Voyager-mission and Mathieu-group code; the perfect-code family, threshold at its proven distance | 23 - 12 = 11 ∧ (7 - 1) / 2 = 3 ∧ 2 ^ 11 = 2048 | fault-tolerant-design qpu example · ftqc-all · npm run textbooks | 1 | 08f6007c |
pascal_rule | Pascal's rule, the defining recurrence of the binomial coefficient C(n, k) = C(n−1, k) + C(n−1, k−1): C(8,3)=56=35+21, C(8,2)=28=21+7, C(7,3)=35=20+15. The textbook meaning of the 22 clay relations of the form choose a b = choose a b (the register's binomial equals the standard one); each clay case is named pascal-rule-<value> (relation_28 → pascal-rule-28) | 56 = 35 + 21 ∧ 28 = 21 + 7 ∧ 35 = 20 + 15 | clay qpu example · clay-register · npm run textbooks | 1 | 4a2dc9c4 |
euler_fermat | Fermat's little theorem, a^(p−1) ≡ 1 (mod p) for a prime p (the p−1 case of Euler's theorem): 2⁶≡1 mod 7, 3⁴≡1 mod 5, 2⁴≡1 mod 5. The textbook meaning of the clay relations over powMod (modular exponentiation); each named euler-fermat-<value> | 2 ^ 6 % 7 = 1 ∧ 3 ^ 4 % 5 = 1 ∧ 2 ^ 4 % 5 = 1 | clay qpu example · clay-register · npm run textbooks | 1 | 376cbc9c |
bilinear_symmetry | the commutative law a·b = b·a, the symmetry of a bilinear form: 9·6=6·9, 7·4=4·7. The textbook meaning of the clay relations qaoaZz a b = qaoaZz b a and qaoaZz = qaoaX (the ZZ/X mixer symmetry); each named bilinear-symmetry-<value> | 9 * 6 = 6 * 9 ∧ 7 * 4 = 4 * 7 | clay qpu example · clay-register · npm run textbooks | 1 | 2907dd63 |
euler_totient | Euler's totient at twice a prime, φ(2p) = p − 1: φ(74) = φ(2·37) = 37 − 1 = 36, the degree of the cyclotomic factor Φ₇₄ of the thousand-bit integer 2^999+1. The textbook meaning of relation_36; named euler-totient-36 | 37 - 1 = 36 ∧ 2 * 37 = 74 | clay qpu example · clay-register · npm run textbooks | 1 | 6c024c03 |
fibonacci | the Fibonacci recurrence F(n) = F(n−1) + F(n−2): 5+8=13, 8+13=21, 13+21=34. The textbook meaning of the clay relations over fibFusion; each named fibonacci-<value> | 5 + 8 = 13 ∧ 8 + 13 = 21 ∧ 13 + 21 = 34 | clay qpu example · clay-register · npm run textbooks | 1 | 344cb314 |
factorial | the factorial n! = n·(n−1)!: 1·2·3·4 = 24 = 4!, 5·24 = 120 = 5!. The textbook meaning of the clay relations over factorial; each named factorial-<value> | 1 * 2 * 3 * 4 = 24 ∧ 5 * 24 = 120 | clay qpu example · clay-register · npm run textbooks | 1 | 298f983a |
magic_constant | the magic constant of the order-3 magic square, (1 + … + 9) / 3 = 15 (the common row, column and diagonal sum): Σ₁⁹ = 45, 45/3 = 15. The textbook meaning of relation_15 (magicBlock = glProd hexbit seed); named magic-constant-15 | 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 = 45 ∧ 45 / 3 = 15 ∧ 3 * 15 = 45 | clay qpu example · clay-register · npm run textbooks | 1 | 143f33a0 |
two_pow_odd_mod_three | two raised to any odd exponent is two modulo three: proved by induction, no exponent evaluated, so it holds at the thousand-bit scale where 2^999 is never materialised — the lemma behind 3 dividing 2^999 + 1 | 2 ^ (2 * n + 1) % 3 = 2 | algorithm qpu example · algorithm-factor-1000-bit · npm run textbooks | 1 | deb79435 |
thousand_bit_width | the thousand-bit test integer N = 2^999 + 1 has exactly 1000 bits: 2^999 ≤ N ≤ 2^1000, proved structurally so the 300-digit number is never computed | 2 ^ 999 ≤ 2 ^ 999 + 1 ∧ 2 ^ 999 + 1 ≤ 2 ^ 1000 | algorithm, fold, match qpu example · algorithm-factor-1000-bit · qpu example · fold-speak-thousand · qpu example · chat-thousand · npm run textbooks | 1 | 5fda9070 |
tuning_ratio | gcd(432, 440) = 8, so 432 : 440 = 54 : 55, and the difference is 8 Hz. ISO 16 states the standard tuning frequency, the note A at 440 Hz, and does not state this ratio. | Nat.gcd 432 440 = 8 ∧ 432 / 8 = 54 ∧ 440 / 8 = 55 ∧ 432 * 55 = 440 * 54 ∧ 440 - 432 = 8 ∧ 55 - 54 = 1 | clay qpu example · clay-register · npm run textbooks | 1 | 4f22c56a |
questions_matched | every question read from a source Payload holds is decided or a lead: the questions less the leads are the decided ones, a lexical neighbour counted a lead | total - leads = decided | match qpu example · match-questions · npm run textbooks | 3 | b3d1d71b |
news_problems | the news define the problems every day and the QPU provides the solutions: matchNews reads each news item as a problem and decides it — served (the call that answers it), impossible (the bound that proves it cannot) or unknown (a lead to develop) — so the served, the impossible and the unknown make the items, served from qpu.uuidna.com under the licence and priced | total - impossible - unknown = served | match qpu example · match-news · npm run textbooks | 3 | a97bd448 |
search_proven | each theorem is a real textbook scenario whose says uses respected terminology (UUID, seal, ISO, coil — never Clay axiom names), so full-text search over the textbook (textbook { search } / searchTextbookPrograms) returns usable programs: the examples that replay the hit, each a tool with its arguments and the programmable schema beside the kernel-accepted proof; MCP and Payload lexical search (match) carries the same proof; the proven and the unproven make the answers | total - unproven = proven | match, textbook qpu example · match-search · qpu example · textbook-search-programs · npm run textbooks | 3 | f1cbc148 |
editorial_posts | autonomous editorial management per tenant, monetising on tenant specifics: editorial turns the day's solved news into the tenant's blog — each served problem a draft post (Payload publishing, the editor publishes at will), priced by the tenant's own catalogue, and each unknown the editorial backlog — so the posts and the backlog make the items; the verified combinatorics write the posts and Payload's validations verify them, run daily as the qpu-news-solve Payload job (newsSolveTask), never auto-deployed | items - backlog = posts | match qpu example · match-editorial · npm run textbooks | 3 | 07d1956e |
ports_cover | every combination of the adapters ported onto Cloudflare is complete or names the missing link that blocks it: the combinations less the blocked ones are the complete ones, however many adapters the app grows to | total - blocked = complete | configure qpu example · configure-adapters-port · npm run textbooks | 3 | 4af07013 |
harmonic_default | harmonic options by default: the referrer's address, or the a432 key, reduced modulo the number of combinations a schema's enums hold is always below that number, so the default it names is always one of the combinations | k % n < n | fold, payload qpu example · fold-harmonic · qpu example · payload-hooks-collapse · npm run textbooks | 2 | 7f38c8a9 |
free_or_coil | every call is free or a coil, decided by the licence: only the pure algebraic formulas are free, every other call is covered by the licence and billed by the coins; the free and the coils make the calls | calls - free + free = calls | metrics, repository qpu example · metrics-bill · qpu example · repository-penalty-way · npm run textbooks | 3 | d2422f78 |
authorship_tracked | the author's records, counted from the tree's PRECEDENCE table, hold the QPU's DOI 1 time and Gneezy and Rustichini's 0 times | 1 = 1 ∧ 0 = 0 | match qpu example · match-doi-own · qpu example · match-doi-external · npm run textbooks | 1 | d6cd3bcc |
lead_cells | combineLeads: a432 builds every lead combination — the key 432 is 2⁴ · 3³, the product of the seven radices [2, 2, 2, 2, 3, 3, 3]; the a432 key reduced mod 432 names cell 0; and every cell below 432 read as its mixed-radix digits and encoded again is itself, so every lead lands in exactly one cell | 2 ^ 4 * 3 ^ 3 = 432 ∧ 2 * 2 * 2 * 2 * 3 * 3 * 3 = 432 ∧ 432 % 432 = 0 ∧ i % 2 + 2 * (i / 2 % 2) + 4 * (i / 4 % 2) + 8 * (i / 8 % 2) + 16 * (i / 16 % 3) + 48 * (i / 48 % 3) + 144 * (i / 144 % 3) = i | leads qpu example · leads-combinations · npm run textbooks | 3 | 05376c06 |
session_partition | runSession: every directive of every session lands in exactly one of four classes — folded into an Open work item, proposed as a new one, acted on where it was said once, or an assent — so the four counts sum to the directives read | c = 0 ∨ c = 1 ∨ c = 2 ∨ c = 3 | leads qpu example · leads-session · npm run textbooks | 3 | 02d14211 |
sitemap_leads | sitemapLeads: every url of a sitemap (sitemaps.org: loc, lastmod) is refused by name, covered by a hand-written lead, or a lead of its own — the three counts sum to the urls handed over, so nothing the site lists is dropped | c + l + (u - v) = u | leads qpu example · leads-sitemap · npm run textbooks | 3 | cca73226 |
rosetta_conventions | the Clay rosetta: the unit seeds a value by its last decimal digit and the tree by its digital root; σ₁₀ holds on both sides for every n, and the two conventions name the same seed exactly when n mod 9 and n mod 10 agree (3432: 3 against 2; 15: 6 against 5), a difference of convention, never of error | (n % 10 + (10 - n % 10) % 10) % 10 = 0 ∧ 1 + (n - 1) % 9 + (10 - (1 + (n - 1) % 9)) = 10 ∧ 3432 % 9 = 3 ∧ 3432 % 10 = 2 ∧ 15 % 9 ≠ 15 % 10 | clay qpu example · clay-rosetta · npm run textbooks | 1 | 6faf8d18 |
binding_zero_hex_path | binding 0 (the qpuRaidDb adapter) is the filesystem: hexPath puts a document at g1/g2/g3/<uuid>, the three middle groups of its address (four hex digits each, so one program's versions share a folder) and the 36 characters of the address, 51 in all, the R2 key and the GCS object of the same document; 65 536 folders a level; Payload's qpu-raid plugin (qpuRaid) writes each version once through getBinding0 with a pointer to the latest and reads back only what its address verifies, wherever its file lies; RAID_ORDER puts binding 0 last on every profile, so raidRead and readLeads always have a place to read when Payload does not answer | 4 + 1 + 4 + 1 + 4 + 1 + 36 = 51 ∧ 16 * 16 * 16 * 16 = 65536 | mongo qpu example · raid-binding0-mirror · qpu example · raid-binding0-restore · npm run textbooks | 1 | a2c920ff |
raid_bit_zero_verify | verifyCopies: each binding's copy of a version is verified by the address its own bytes recompute (bit 0), missing, or differing, so the three counts sum to the bindings; with one verified copy the rebuilds (missing and differing) are fewer than the bindings, each written from a verified copy at its middle-part path, and a file outside that path is moved there; Payload runs it as the qpu-raid-verify batch | m + d + v = b ∧ m + d < b | mongo qpu example · raid-bit-zero-verify · npm run textbooks | 3 | 69856df8 |
reflection_by_shape | listReflections and getReflections: every textbook theorem reflected by its shape, never assumed — σ reverses order on the naturals, so a ≤ b gives σ − b ≤ σ − a, and an implication gives its contrapositive; equalities, conjunctions, disjunctions and equivalences reflect by symmetry part by part, and each converse is proved, refuted by a counterexample the evaluate of the expressions finds and the kernel decides, or left open | d - b ≤ d - a ∧ (¬ Q → ¬ P) | textbook qpu example · textbook-reflected · npm run textbooks | 1 | 5922dc8a |
ancient_law | the ancient foundation fused into the court is four codes (Ur-Nammu, Hammurabi, the Twelve Tables, the Corpus Juris Civilis) and five maxims (audi alteram partem, nemo iudex in causa sua, nulla poena sine lege, ei incumbit probatio, res judicata) = nine entries of ANCIENT_LAW, and the burden-of-proof maxim ei incumbit probatio is exactly this tree's duty legal_only_the_proven_is_admitted | 4 + 5 = 9 | legal qpu example · legal-ancient · npm run textbooks | 1 | 1b50a362 |
merge_collision | merge: every address the edits name is kept, collided or removed; a collision holds two contents; the merge in either order is one address with one collision, and an edit over the base's content stands without one | 1 + 1 + 0 = 2 ∧ 2 = 2 ∧ 2 - 1 = 1 ∧ 1 + 1 + 0 = 2 | payload qpu example · payload-merge-collision · qpu example · payload-merge-collision-reversed · qpu example · payload-merge-edit-stands · npm run textbooks | 1 | 2344065f |
set_address_canonical | a config set is its n given members less their r repeats, addressed by the canonical text of the distinct ones (never a newline join, under which one member holding a newline is two); on distinct members the union of a and b is a + b less their intersection i | n - r + r = n ∧ u = a + b - i | configure qpu example · configure-sets-given · npm run textbooks | 3 | c35b3348 |
entry_canonical | one document is one entry: of its three writes (its 2 · 1 key orders and a key whose value is undefined) two fold into the first one's address, the canonical text (canonicalText, entryText) folded, never the key order JSON.stringify keeps | 3 - 1 = 2 ∧ 2 * 1 = 2 | mongo qpu example · mongo-insert-canonical · npm run textbooks | 1 | 47841d1c |
fold_slices | foldLedger cuts a text into slices of itself under the bound, each piece keeping its rows' newlines: the 5 pieces' bytes sum to the whole's 11, and the pieces unfolded are the whole, nothing inserted between them | 2 + 3 + 2 + 2 + 2 = 11 ∧ 5 * 3 ≥ 11 ∧ 2 + 3 + 3 = 8 | fold qpu example · fold-slices-exact · qpu example · fold-unfold-exact · npm run textbooks | 1 | dbfe3fb7 |
reflect_widths | the reflective cut answers its 20 nibbles beside its 14 faces: each face is the quotient wide, the first remainder faces one wider, so the widths follow from the two numbers and a decoder holding the witnesses rebuilds the integer exactly, leading zeros included | 20 / 14 * 14 + 20 % 14 = 20 ∧ 20 % 14 < 14 | fold qpu example · fold-reflect-widths · npm run textbooks | 1 | e3572334 |
references_name_collision | createReferenceGraph: every reference resolves to one document or is dangling; a name two documents claim is a collision listed with both and resolved to neither | 0 + 1 = 1 ∧ 1 = 1 ∧ 2 = 2 | payload qpu example · payload-references-collision · npm run textbooks | 1 | 89da6b11 |
css_one_source | style, the one cascade source: the hue of an address is its handle mod 360 in the block it wears, the css tool and the presentation alike — one value per custom property | 23963508 % 360 = 108 ∧ 108 = 108 | css, fold qpu example · css-one-source · qpu example · fold-hex-one-source · npm run textbooks | 1 | f5818346 |
div_zero | division by zero is total in the kernel, for every number: x / 0 = 0 and x % 0 = x for every natural x, z / 0 = 0 for every integer z (Lean's convention, Mathlib's div_zero for fields); 0 has no inverse, so (x / 0) · 0 = x fails for x ≠ 0 | x / Nat.zero = Nat.zero ∧ x % Nat.zero = x ∧ z / (Nat.zero : Int) = (Nat.zero : Int) | match qpu example · match-div-zero · npm run textbooks | 1 | c5554839 |
receipt_binds_sha256 | a receipt is bound by the SHA-256 of its content, recomputed by any holder: 256 bits written as 64 hex characters, a crafted collision about 2^128 trials, where the 64-bit fold collides by birthday in about 2^32 and a fold address passes the seal by construction, so a seal flag on a fold decided nothing; the same binding names an untouched result by the fold and the SHA-256 of its own canonical text, so seal { tamper } reads it authentic | 256 / 4 = 64 ∧ 64 / 2 = 32 ∧ 256 / 2 = 128 ∧ 2 ^ 32 < 2 ^ 128 | algorithm qpu example · algorithm-factor-order-composite · qpu example · algorithm-impossible-decode-wrong-witness · qpu example · algorithm-factor-test-integer · npm run textbooks | 1 | a09dad15 |
check_three_states | a check has three states — passed (recomputed now), contradicted (a witness present and disagreeing) and missing (the witness not supplied, null) — so the decided checks are all but the missing ones and a pass is one of them: a neighbour link of caller strings, a decode without its address and an artifact without its bytes are missing, never passed | total - missing = passed + contradicted ∧ passed ≤ total - missing | verify, seal qpu example · verify-neighbours-asserted · qpu example · verify-neighbours-witnessed · qpu example · verify-neighbours-contradicted · qpu example · seal-artifacts-digest-alone · npm run textbooks | 3 | 37d8a9ff |
digest_on_round_trip | a proof check emits its digest (a digest, never a signature) exactly for the calls whose theorem's examples hold the call again: the digests are the round trips, so a call without one gets nothing for the block's proof hook to MAC and sign | digests ≤ checked ∧ checked - digests = checked - roundTrips | verify qpu example · verify-call · qpu example · verify-call-no-round-trip · npm run textbooks | 3 | 35cb3661 |
witness_move_computed | the coins of a witness move are computed from the move: the step down from 2k to 2(k − 1) pays (2k − 2(k − 1))/2 = 1, the step up to 2(k + 1) collects 1, and the net is their difference, 0, for every k ≥ 1 | (2 * k - 2 * (k - 1)) / 2 = 1 ∧ (2 * (k + 1) - 2 * k) / 2 = 1 ∧ (2 * (k + 1) - 2 * k) / 2 - (2 * k - 2 * (k - 1)) / 2 = 0 | verify qpu example · verify-witness-move · qpu example · verify-witness-move-110 · npm run textbooks | 3 | 992175f6 |
correction_by_majority | the correction branch is reached with the real majority: when more than half of the copies agree, the others are fewer than the agreeing ones, so correction decodes with no swap; without a majority handling takes over | total - votes < votes | e2e qpu example · e2e-corrected-by-majority · npm run textbooks | 3 | f618831e |
royalty_fractal | royalty: the fractal shares never exceed the fee — at the ratio 2/110 the example's royalty reports, the first share ⌊f·2/110⌋ leaves a remainder at least 108/2 times itself, and while the remainder r covers 108/2 of the last share p, the next share s = ⌊p·2/110⌋ fits under r and leaves r − s covering 108/2 of s: by induction over the levels the shares sum to at most the fee | f * 2 / 110 ≤ f ∧ 2 * (f * 2 / 110) ≤ 108 * (f - f * 2 / 110) ∧ s ≤ r ∧ 2 * s ≤ 108 * (r - s) | stripe qpu example · stripe-royalty · npm run textbooks | 3 | 960837dc |
royalty_conserved | royalty: the shares paid p stay under the fee f (textbook_royalty_fractal), so the remainder x = f − p to revenue:author makes shares and remainder the fee exactly: the entry posts +f and −p − x, Σ = 0, which balance measures again from the stored postings; a share held in escrow is still posted, never lost | p + x = f ∧ f - p - x = 0 | stripe qpu example · stripe-royalty · qpu example · stripe-royalty-escrow · npm run textbooks | 3 | 3bfa1582 |
witness_books_nothing | witness, mintWitnessCoins and contribution: every item is passed (p), missing (m) or contradicted (c), the three summing to the items n, and the coins booked k are the passed alone, so k + m + c = n and k ≤ n − m − c — a missing witness books nothing (a witness gap, listed, its share held in escrow), a contradicted one books nothing (a refusal) | k + m + c = n ∧ k ≤ n - m - c | stripe, verify qpu example · stripe-mint-witnesses · qpu example · stripe-idea-contribution · qpu example · stripe-royalty-escrow · qpu example · verify-witnesses-merge · npm run textbooks | 3 | b7671059 |
witness_states | one judge decides a statement for the match, the chat and the search alike: each witness passed (recomputed now), contradicted (present and disagreeing) or missing (named) — the schema bound of the door that answers, the arithmetic the statement writes, the kernel's theorem or the call made now with its example replayed, each value it claims (a number alone in its clause continuing the claim before it; a number neither an input nor a claim witnessed only by a value equal to it) against the values the answer and its routed theorem compute (numbers reads the numbers, sides a theorem's computed sides, the side its own words name deciding first, evaluateRouted binds the statement's numbers to the routed theorem as the chat does), its polarity, and the words a named theorem does not state; the present, the missing and the contradicted make the witnesses, and a statement is served only when none is missing and none contradicted, every witness present (solid when the kernel accepts the theorem naming the answer, liquid else); one contradicted is a collision (impossible, the chat answers with it), one missing gas (unknown), and a search is solved only when served | present = witnesses ∧ contradicted = 0 ∧ missing = 0 | match qpu example · match-witness-p-np · qpu example · match-witness-planck · qpu example · match-witness-planck-value · qpu example · match-witness-negation · qpu example · match-witness-willow · qpu example · match-witness-willow-wrong · qpu example · match-search-witnessed · qpu example · chat-witness-planck · qpu example · chat-witness-computed · qpu example · match-witness-loose · npm run textbooks | 3 | fa79c1a4 |
blockchain_hash_links | ISO 22739:2024 3.6, 3.4 and 3.44: a blockchain is a distributed ledger with confirmed blocks organized in an append-only, sequential chain using hash links; a block header includes a hash link to the previous block, if present; the genesis block is the first block and has no previous block — so n blocks carry n − 1 hash links and the genesis block none (NISTIR 8202 §3.7: each block holds the hash of the previous block's header); in the tree the header is the UUID the content folds to and the hash link is the predecessor content folded back to the id the block names (verify prev) | (n - 1) + 1 = n ∧ 1 - 1 = 0 | verify qpu example · verify-blockchain-genesis · qpu example · verify-blockchain-linked · qpu example · verify-radar · npm run textbooks | 3 | 597438aa |
blockchain_tamper_evident | NISTIR 8202 §3.7 Chaining Blocks: a changed block has a different hash, so every subsequent block, holding the previous header's hash, changes too, and altered blocks are detected and rejected; of n blocks with the i-th altered, the i before it still link and the n − i from it onward are evident, the altered block itself first (its content no longer folds to its header) — ISO 22739:2024 3.23 Note 1: a distributed ledger is immutable, tamper-resistant, tamper-evident and append-only | i + (n - i) = n ∧ 1 ≤ n - i | verify qpu example · verify-blockchain-tampered · npm run textbooks | 3 | 7532fe7e |
sha256_fips_180_4 | FIPS 180-4 Figure 1: SHA-256 digests 256 bits, 32 bytes shown as 64 hexadecimal characters (NISTIR 8202 §3.1 reads it the same), over 512-bit message blocks of sixteen 32-bit words: the seal tool's sha256 of a block's text, the hash value (ISO 22739:2024 3.4 Note 1) a header carries | 256 / 8 = 32 ∧ 256 / 4 = 64 ∧ 512 / 32 = 16 ∧ 2 * 256 = 512 | seal qpu example · seal-block-sha256 · npm run textbooks | 1 | 78d418b6 |
sha3_fips_202 | FIPS 202 §5.2 and §6.1: KECCAK[c] = SPONGE[KECCAK-p[1600, 24], pad10*1, 1600 − c], SHA3-256(M) = KECCAK[512](M || 01, 256) and SHA3-512(M) = KECCAK[1024](M || 01, 512): the capacity is twice the digest and the rate the rest of the 1600-bit state, 1088 and 576 bits; the seal tool computes both with sha3 | 1600 - 512 = 1088 ∧ 512 = 2 * 256 ∧ 1600 - 1024 = 576 ∧ 1024 = 2 * 512 | seal qpu example · seal-block-sha3 · npm run textbooks | 1 | 603764ff |
ml_dsa_fips_204 | FIPS 204 Table 2, sizes in bytes: ML-DSA-44 public key 1312 and signature 2420 (category 2), ML-DSA-65 1952 and 3309 (category 3), ML-DSA-87 2592 and 4627 (category 5): what a block's digital signature (ISO 22739:2024 3.22, data appended to authenticate origin and integrity) costs on the wire grows with the category; the seal tool's sign plan names the set | 1312 + 2420 = 3732 ∧ 1952 + 3309 = 5261 ∧ 2592 + 4627 = 7219 ∧ 3732 < 5261 ∧ 5261 < 7219 | seal qpu example · seal-block-sign-ml-dsa-44 · npm run textbooks | 1 | 7836c2c0 |
iso_22739_terms_read | ISO 22739:2024, the blockchain and distributed ledger technology vocabulary (ISO/TC 307; ICS 35.030 IT security, 35.240.40 IT applications in banking): 99 terms, 3.1 to 3.99; 45 read in full from the public sample and 3.46 hash function cut mid-definition — asset, block, block data, block header, block reward, blockchain, blockchain system, blockchain technology, confirmed, consensus, consensus mechanism, cryptoasset, cryptocurrency, cryptography, decentralized application, decentralized identifier, decentralized identity, decentralized system, digital asset, digital signature, distributed ledger, distributed system, DLT and its account, address, bridge, governance, network, node, oracle, platform, solution, system and user, double spending, entity, failure, fault tolerance, finality, fungible, fungible token, genesis block, hard fork — and 53 unread (3.47 hash link to 3.99: hash value, immutability, ledger, Merkle tree, nonce, timestamp, transaction record among them), the lead iso-22739-terms-unread; the court admits only the read | 45 + 1 + 53 = 99 ∧ 99 - 46 = 53 | verify qpu example · verify-iso-22739-terms-read · npm run textbooks | 1 | 219ec503 |
blockchain_transfer_once | ISO 22739:2024 3.15, 3.27 and 3.37 with NISTIR 8202 §3.4: a cryptocurrency is a cryptoasset designed to work as a medium of payment or value exchange, the transfer of assets verified in the DLT system; a DLT address designates the originating source or destination of a transaction (NIST: the to and from endpoints, derived from a public key by a cryptographic hash function); an electronic funds transfer of one unit from a to b conserves the total, a − 1 + b + 1 = a + b, booked once in double entry (textbook_coins_coils_balanced), and control transferred more than once (2 > 1) is double spending, a failure of the platform | (a - 1) + (b + 1) = a + b ∧ 1 < 2 | verify qpu example · verify-blockchain-transfer-once · npm run textbooks | 3 | 0e7a351c |
only_the_proven_is_admitted | the consolidated 1000-bit surface admits only what is proven: 1000 bits are 125 bytes exactly, fourteen reflections of 71 bits and six more rebuild the width exactly, and of the five sub-proofs (reflections, sigma trapdoor, DNA cross-encryption, Glagolitic width, Clay arithmetic) none is left asserted (5 − 5 = 0); the fold tool answers verified and sealed only when every one holds | 1000 / 8 = 125 ∧ 125 * 8 = 1000 ∧ 1000 % 71 = 6 ∧ 14 * 71 + 6 = 1000 ∧ 5 - 5 = 0 | fold qpu example · fold-proven · npm run textbooks | 1 | 138a3f2c |
receipts_partitioned | a changed fold partitions the recorded receipts: holds + stale + wrong = total (on quintessay-payload's contribution receipt with its resealed and its two-leaf controls, 1 + 1 + 1 = 3), the invalidated ones are total − holds = stale + wrong = 2, at least one receipt holds under the current fold and fewer hold than were recorded; the seal tool's receipts finder recomputes each receipt under uuidna's current merkleGravity and names the earlier fold that reproduces a stale one | 1 + 1 + 1 = 3 ∧ 3 - 1 = 1 + 1 ∧ 0 < 1 ∧ 1 < 3 | seal qpu example · seal-receipts · npm run textbooks | 1 | bb775006 |
stale_receipt_refuses_deploy | a deploy waits on every recorded receipt: of the two the docket holds by id after the newest record of each is taken (quintessay-payload's resealed contribution and an unresealed mirror), holds + stale + wrong = 1 + 1 + 0 = 2, the invalidated ones are total − holds = stale + wrong = 1, and one invalidated receipt is enough to refuse; findStaleReceipts decides the pre-deploy rule receipts | 1 + 1 + 0 = 2 ∧ 2 - 1 = 1 + 0 ∧ 0 < 2 - 1 | repository qpu example · repository-predeploy-receipts · npm run textbooks | 1 | bf993f42 |