@ceccec/millennium-solutions 9.3.3 → 9.3.5

package/README.md

@@ -2,6 +2,20 @@
 
 **Author:** Tsvetan Rouschev · License: CC BY-NC-ND 4.0 · DOI [10.5281/zenodo.21819217](https://doi.org/10.5281/zenodo.21819217)
 
+```bash
+npm install @ceccec/millennium-solutions
+```
+
+```js
+import { toUuid, merkleFold } from '@ceccec/millennium-solutions'
+
+const a = toUuid('hello')                      // the same input gives the same address, for anyone, with no key
+const root = merkleFold([a, toUuid('world')])  // many addresses fold into one
+console.log(a, root)
+```
+
+An ES module with TypeScript types for Node 22.12 or later; `import` and `require` both work.
+
 Every claim in this file is a statement paired with a decidable test, put through `adjudicate()`, and written
 only if its decidable test holds. It is generated by `scripts/pages.ts`, which fails rather than write an
 unsealed sentence — and the same generator writes the homepage, so the two cannot drift apart.
@@ -11,10 +25,10 @@ last because the orbit never reaches it.
 
 ## 1 · What is proved
 
-- The formal layer holds 816 kernel-accepted declarations across 33 files, and no file uses sorry or native_decide outside a comment.
-  <sub>SEALED · `03bb8fd7-8470-8985-b90f-d597fa390e42`</sub>
-- 630 of those 816 are THEOREMS by this deposit's own rule — they close by decide, which is to say the kernel evaluates the proposition over its whole finite domain rather than accepting a declaration; the remaining 186 close by rfl and are declarations.
-  <sub>SEALED · `d27b2416-8049-8b5b-ac51-a8cefb31d7c2`</sub>
+- The formal layer holds 815 kernel-accepted declarations across 33 files, and no file uses sorry or native_decide outside a comment.
+  <sub>SEALED · `9180458c-b88e-8e53-a424-7f6b62f8a719`</sub>
+- 630 of those 815 are THEOREMS by this deposit's own rule — they close by decide, which is to say the kernel evaluates the proposition over its whole finite domain rather than accepting a declaration; the remaining 185 close by rfl and are declarations.
+  <sub>SEALED · `e1a852b2-7a11-82db-a82f-0bc1cc99104c`</sub>
 - 891 of them are sealed into the ledger, each carrying a receipt derived from the one before it.
   <sub>SEALED · `f09699de-82af-8255-ace6-52cc69755a6f`</sub>
 
@@ -86,7 +100,7 @@ results; it is the result, read off the same arithmetic that produced the table.
 
 ## 7 · The proofs, as they document themselves
 
-33 Lean files in 7 wings, 816 declarations of which 807 are theorems. The prose in this section is read out of the
+33 Lean files in 7 wings, 815 declarations of which 806 are theorems. The prose in this section is read out of the
 sources — their frontmatter, their header comments and the comment above each theorem. Editing a proof edits
 this page; there is nowhere else to keep the description in step.
 
@@ -134,7 +148,7 @@ this page; there is nowhere else to keep the description in step.
 
 **The Millennium floor** — `index.lean`, 11 theorem(s). Bounded, so the credit stops where the earlier work does: what is NOT prior art is the use of that orbit as a floor for what this deposit does   and does not settle, which is a statement about this repository and has no earlier author.   Verification by exhaustion in Lean is this deposit's contribution, and verification is not discovery. prior_art_search: literature search performed 2026-09-05, terms "doubling sequence modulo 9 orbit   1 2 4 8 7 5 cyclic group generator digital root"; prior art found and credited. prior_art_pool: bounded   digit arithmetic of the doubling sequence; searchable independently of this deposit.   BOUNDED means a search is well posed and simply has not been run — the row is unclassified because   nobody looked. UNBOUNDED means the subject is this artifact, so there is no pool to search and the   row will stay unclassified however much work is done. They look identical in a count and need   opposite responses, which is the distinction uuidna-49 asked for and nobody had drawn. prior_art_own: the Millennium floor, computed from this sequence The Millennium floor — seven honest theorems, one per problem, COMPUTED from the sequence.
 
-**Light, space and time — arithmetic on numbers a standards body fixed** — `light.lean`, 16 theorem(s). Poids et Mesures, not results of this deposit: the metre from the speed of light (17th CGPM, 1983) and   the seven defining constants fixed exactly in the 2019 revision of the SI, effective 20 May 2019   (BIPM, https://www.bipm.org/en/measurement-units/si-defining-constants). Nothing here measures anything.
+**Light, space and time — arithmetic on numbers a standards body fixed** — `light.lean`, 15 theorem(s). Poids et Mesures, not results of this deposit: the metre from the speed of light (17th CGPM, 1983) and   the seven defining constants fixed exactly in the 2019 revision of the SI, effective 20 May 2019   (BIPM, https://www.bipm.org/en/measurement-units/si-defining-constants). Nothing here measures anything.
 
 **Every phenomenon this deposit touches, and the rule for the rest** — `phenomena.lean`, 4 theorem(s). Générale des Poids et Mesures (2019 revision, effective 20 May 2019); the electrochemical results are   Michael Faraday's laws of electrolysis, 1834, and the standard enthalpy of combustion of hydrogen.   Every physical result named here has an earlier author or a standards body, and none is this deposit's.
 
@@ -170,7 +184,7 @@ this page; there is nowhere else to keep the description in step.
 
 **Recovered — claims that computed and were withdrawn for want of a proof** — `recovered.lean`, 15 theorem(s). material, credited. What is NOT prior art is that these particular statements sat WITHDRAWN in this   deposit's ledger, each recorded as "not backed by a Lean proof. Its evidence is a TypeScript test",   while every one is decidable in a line. prior_art_search: literature search performed 2026-09-05, terms "units and non-units of Z/9 multiplicative   inverses group of units modulo 9"; prior art found and credited.
 
-20 of 816 declarations carry no comment of their own and are shown here as the gap they are, not
+20 of 815 declarations carry no comment of their own and are shown here as the gap they are, not
 filled with a template.
 
 ## 8 · What this build measured about itself
@@ -180,19 +194,19 @@ Read from the artefacts at build time, never carried between runs.
 | measure | value |
 |---|---|
 | ledger entries | 2,755 — 344 octaves and 3 over |
-| standing — carries its own proof | **807** |
-| carried — withdrawn on its own evidence, proved by a live theorem | **434** |
+| standing — carries its own proof | **806** |
+| carried — withdrawn on its own evidence, proved by a live theorem | **435** |
 | withdrawn — nothing proves it | 1,514 |
 | proved in total | **1241** of 2,755 |
-| standing keys → distinct theorems | 807 sealed, 0 of them keyed twice, 0 unresolvable |
-| Lean files · theorems | 33 · 807 theorems (630 closed by exhaustion, axiom-free · 177 proved for every value on propext and Quot.sound) + 9 rfl declarations |
-| proved `by decide` | 630 of 816 |
+| standing keys → distinct theorems | 806 sealed, 0 of them keyed twice, 0 unresolvable |
+| Lean files · theorems | 33 · 806 theorems (630 closed by exhaustion, axiom-free · 176 proved for every value on propext and Quot.sound) + 9 rfl declarations |
+| proved `by decide` | 630 of 815 |
 | claims a machine can render | 103 of 1,555 |
 | claims needing an author | 1,452 — reported, never faked |
 
-**On `carried`.** 434 entries were withdrawn for want of a Lean proof and have since been given one, at a new key. Nothing is un-revoked: the original's own evidence is still a TypeScript test, and rewriting its status would erase the fact that it did not hold on what it had. The record says both — withdrawn on its own evidence, standing through the theorem that carries it.
+**On `carried`.** 435 entries were withdrawn for want of a Lean proof and have since been given one, at a new key. Nothing is un-revoked: the original's own evidence is still a TypeScript test, and rewriting its status would erase the fact that it did not hold on what it had. The record says both — withdrawn on its own evidence, standing through the theorem that carries it.
 
-**Why the withdrawn were withdrawn.** 1,386 no Lean proof · 457 tested the removed lexical gate · 60 other · 35 its Lean source was deleted or renamed · 10 circular by construction. Nothing is deleted: the ledger is append-only, so an entry that stopped holding is marked in place with its reason and keeps its receipt.
+**Why the withdrawn were withdrawn.** 1,386 no Lean proof · 457 tested the removed lexical gate · 61 other · 35 its Lean source was deleted or renamed · 10 circular by construction. Nothing is deleted: the ledger is append-only, so an entry that stopped holding is marked in place with its reason and keeps its receipt.
 
 **What verification costs.** Proving the set touches all 16,384 leaves; verifying membership afterwards touches 14 — one sibling per level. That is **1,170× less work**, exactly, and the factor grows with the set because N/log N grows. Wall-clock varies with the machine and is left in the build output rather than pinned here. It is not sub-nanosecond and nothing here is: the advantage is a smaller exponent, not a faster clock. The counting is proved in `speed.lean`.
 
@@ -225,4 +239,4 @@ whether the work restates someone earlier. [The paper](/paper) typesets every st
 
 ---
 
-*15 claims, all verified · 807 Lean theorems · 2755 ledger entries · trial root `549339aa-28bc-899a-86e9-5c2d8a42080e` · integrity, not truth*
+*15 claims, all verified · 806 Lean theorems · 2755 ledger entries · trial root `fa3c08c7-7003-80ea-9a50-de79f9225ad7` · integrity, not truth*

package/dist/mod.core.d.ts

@@ -0,0 +1,9 @@
+export { toUuid, merge, foldPair, merkleFold, sealFacets, gcdBigInt } from './src/0/index.js';
+export { entails, curveFitCheck, scaleCheck } from './src/honesty/index.js';
+export { report as honesty } from './src/honesty/index.js';
+export { report as ledger } from './src/0/ledger.js';
+export { report as trinityMatrix } from './src/0/trinity-matrix.js';
+export { report as enumeration } from './src/9/enumeration.js';
+export { report as reflection } from './src/5/reflection.js';
+export { report as aspects } from './src/5/aspects.js';
+export { report as rosetta } from './src/7/rosetta.js';

package/dist/mod.core.js

@@ -0,0 +1,9 @@
+export { toUuid, merge, foldPair, merkleFold, sealFacets, gcdBigInt } from './src/0/index.js';
+export { entails, curveFitCheck, scaleCheck } from './src/honesty/index.js';
+export { report as honesty } from './src/honesty/index.js';
+export { report as ledger } from './src/0/ledger.js';
+export { report as trinityMatrix } from './src/0/trinity-matrix.js';
+export { report as enumeration } from './src/9/enumeration.js';
+export { report as reflection } from './src/5/reflection.js';
+export { report as aspects } from './src/5/aspects.js';
+export { report as rosetta } from './src/7/rosetta.js';

package/dist/src/0/index.d.ts

@@ -0,0 +1,47 @@
+export declare function toUuid(seed: string): string;
+export declare function strictUuidna(value: unknown): string;
+export declare function merge(a: string, b: string): string;
+export declare function gcdBigInt(a: bigint, b: bigint): bigint;
+export declare function seedFromText(text: string, length?: number): number;
+export declare function foldPair(a: string, b: string): {
+    forward: string;
+    reverse: string;
+    bidirectional: boolean;
+    merged: string;
+};
+export declare function merkleFold(leaves: readonly string[]): string;
+export declare function sealFacets<F extends {
+    facet: string;
+    on: boolean;
+}>(tag: string, facets: readonly F[]): {
+    ok: boolean;
+    count: number;
+    facets: (F & {
+        receipt: string;
+    })[];
+    root: string;
+};
+export declare function memoByRoot<T>(name: string, matrix: {
+    root: string;
+}, compute: () => T): T;
+export declare function digitalRoot(n: number): number;
+export declare function gcd(a: number, b: number): number;
+export declare function isPrime(n: number): boolean;
+export declare function modpow(b: number, e: number, n: number): number;
+export declare const TRINITY = 3;
+export declare const BASE: number;
+export declare function digits(): number[];
+export declare function units(): number[];
+export declare function triad(): number[];
+export declare function vortexOrbit(): number[];
+export declare const A432_STEP: number;
+export interface AnimationEngine {
+    readonly running: boolean;
+    start(): void;
+    stop(): void;
+    sync(active: boolean): void;
+    tick(): void;
+    runWhile(active: () => boolean): void;
+    dispose(): void;
+}
+export declare function createAnimationEngine(draw: (time: number) => void): AnimationEngine;

package/dist/src/0/index.js

@@ -0,0 +1,189 @@
+const BYTE_MASK = 0xff;
+const MASK_32 = 0xffffffffn;
+function mul32(a, b) {
+    return Number((BigInt(a >>> 0) * BigInt(b >>> 0)) & MASK_32);
+}
+function hash32(input, seed) {
+    let h = (0x811c9dc5 ^ seed) >>> 0;
+    for (let i = 0; i < input.length; i++) {
+        h ^= input.charCodeAt(i);
+        h = mul32(h, 0x01000193) >>> 0;
+        h ^= h >>> 13;
+    }
+    h = mul32(h ^ (h >>> 16), 0x85ebca6b) >>> 0;
+    h = mul32(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;
+    return (h ^ (h >>> 16)) >>> 0;
+}
+const HEX_BYTE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+function hexByte(value) {
+    return HEX_BYTE[value & BYTE_MASK];
+}
+function bytesFromSeed(seed) {
+    const words = [
+        hash32(seed, 0),
+        hash32(seed, 0x9e3779b9),
+        hash32(seed, 0x243f6a88),
+        hash32(seed, 0xb7e15162),
+    ];
+    return words.flatMap((word) => [
+        (word >>> (8 * 3)) & BYTE_MASK,
+        (word >>> 16) & BYTE_MASK,
+        (word >>> 8) & BYTE_MASK,
+        word & BYTE_MASK,
+    ]);
+}
+const _uuidCache = new Map();
+export function toUuid(seed) {
+    const cached = _uuidCache.get(seed);
+    if (cached !== undefined)
+        return cached;
+    const bytes = bytesFromSeed(seed);
+    bytes[6] = (bytes[6] & 0x0f) | 0x80;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.map(hexByte).join('');
+    const uuid = `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    _uuidCache.set(seed, uuid);
+    return uuid;
+}
+export function strictUuidna(value) {
+    return toUuid('uuidna:' + String(value).normalize('NFC').trim());
+}
+export function merge(a, b) {
+    return toUuid(`${a}:${b}`);
+}
+export function gcdBigInt(a, b) {
+    return b === 0n ? a : gcdBigInt(b, a % b);
+}
+export function seedFromText(text, length = 6) {
+    return Number.parseInt(toUuid(text).replace(/[^0-9a-f]/g, '').slice(0, length) || '0', 16);
+}
+export function foldPair(a, b) {
+    const forward = merge(a, b);
+    const reverse = merge(b, a);
+    return { forward, reverse, bidirectional: forward !== reverse, merged: merge(forward, reverse) };
+}
+export function merkleFold(leaves) {
+    let layer = [...leaves].sort();
+    if (layer.length === 0)
+        return toUuid('empty-mind');
+    while (layer.length > 1) {
+        const next = [];
+        for (let i = 0; i < layer.length; i += 2) {
+            const a = layer[i];
+            const b = layer[i + 1];
+            next.push(b === undefined ? a : merge(a, b));
+        }
+        layer = next;
+    }
+    return layer[0];
+}
+export function sealFacets(tag, facets) {
+    const stamped = facets.map((f) => ({ ...f, receipt: toUuid(`${tag}:${f.facet}:${f.on}`) }));
+    return {
+        ok: stamped.every((f) => f.on),
+        count: stamped.length,
+        facets: stamped,
+        root: merkleFold(stamped.map((f) => f.receipt)),
+    };
+}
+const reportMemo = new Map();
+const reportComputing = new Set();
+export function memoByRoot(name, matrix, compute) {
+    const key = `${name}:${matrix.root}`;
+    if (reportMemo.has(key))
+        return reportMemo.get(key);
+    if (reportComputing.has(key))
+        return {};
+    reportComputing.add(key);
+    try {
+        const value = compute();
+        reportMemo.set(key, value);
+        return value;
+    }
+    finally {
+        reportComputing.delete(key);
+    }
+}
+export function digitalRoot(n) {
+    const r = ((n % 9) + 9) % 9;
+    return r === 0 ? 9 : r;
+}
+export function gcd(a, b) {
+    while (b) {
+        const t = a % b;
+        a = b;
+        b = t;
+    }
+    return a;
+}
+export function isPrime(n) {
+    if (n < 2)
+        return false;
+    for (let d = 2; d * d <= n; d++)
+        if (n % d === 0)
+            return false;
+    return true;
+}
+export function modpow(b, e, n) {
+    let r = 1;
+    b %= n;
+    while (e > 0) {
+        if (e & 1)
+            r = (r * b) % n;
+        b = (b * b) % n;
+        e >>= 1;
+    }
+    return r;
+}
+export const TRINITY = 3;
+export const BASE = TRINITY ** 2;
+export function digits() {
+    return Array.from({ length: BASE }, (_, i) => i + 1);
+}
+export function units() {
+    return digits().filter((d) => gcdBigInt(BigInt(d), BigInt(BASE)) === 1n);
+}
+export function triad() {
+    return digits().filter((d) => gcdBigInt(BigInt(d), BigInt(BASE)) !== 1n);
+}
+export function vortexOrbit() {
+    const orbit = [];
+    let x = 1;
+    do {
+        orbit.push(x);
+        x = (x * 2) % BASE;
+    } while (x !== 1);
+    return orbit;
+}
+export const A432_STEP = 360 / BASE;
+export function createAnimationEngine(draw) {
+    let raf = 0, once = 0, spin = 0, running = false;
+    const schedule = (fn) => typeof requestAnimationFrame === 'function' ? requestAnimationFrame(fn) : 0;
+    const cancel = (id) => {
+        if (id && typeof cancelAnimationFrame === 'function')
+            cancelAnimationFrame(id);
+    };
+    function loop(time) {
+        if (!running)
+            return;
+        draw(time);
+        raf = schedule(loop);
+    }
+    return {
+        get running() { return running; },
+        start() { if (!running) {
+            running = true;
+            raf = schedule(loop);
+        } },
+        stop() { running = false; cancel(raf); raf = 0; },
+        tick() { cancel(once); once = schedule((t) => { once = 0; draw(t); }); },
+        sync(active) { active ? this.start() : (this.stop(), this.tick()); },
+        runWhile(active) {
+            if (running || spin)
+                return;
+            const step = (time) => { draw(time); spin = active() ? schedule(step) : 0; };
+            spin = schedule(step);
+        },
+        dispose() { running = false; cancel(raf); raf = 0; cancel(once); once = 0; cancel(spin); spin = 0; },
+    };
+}

package/dist/src/0/ledger.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/0/ledger.js

@@ -0,0 +1,25 @@
+import { toUuid, merge, merkleFold } from './index.js';
+export function report() {
+    const txs = [
+        { debit: 'funding', credit: 'development', amount: 2 },
+        { debit: 'development', credit: 'research', amount: 1 },
+    ];
+    const debits = txs.reduce((s, t) => s + t.amount, 0);
+    const credits = txs.reduce((s, t) => s + t.amount, 0);
+    let prev = toUuid('genesis');
+    const chain = [];
+    for (const t of txs) {
+        prev = merge(prev, toUuid(t.debit + '|' + t.credit + '|' + t.amount));
+        chain.push(prev);
+    }
+    const root = merkleFold(chain);
+    const root2 = merkleFold(chain);
+    let o = 'content-addressed double-entry ledger (tamper-evident):\n';
+    txs.forEach((t, i) => o += '  ' + t.debit.padEnd(12) + '→ ' + t.credit.padEnd(12) + t.amount + '   addr ' + chain[i].slice(0, 13) + '…\n');
+    o += '  balance: debits ' + debits + ' = credits ' + credits + '  (' + (debits === credits) + ')\n';
+    o += '  merkle root (audit anchor): ' + root.slice(0, 13) + '…   recompute stable? ' + (root === root2) + '\n';
+    o += '\nHONEST: integrity/audit via hashing — transparent, recomputable, holographic (root in every part).\n';
+    o += 'NOT encryption, NOT post-quantum, NOT a reversible message stream. toUuid is FNV (non-crypto,\n';
+    o += '~2^61) — for real integrity use SHA-256; for real PQC use a vetted lattice/hash scheme (ML-KEM, SPHINCS+).';
+    return o;
+}

package/dist/src/0/trinity-matrix.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/0/trinity-matrix.js

@@ -0,0 +1,16 @@
+import { toUuid, foldPair, merkleFold, sealFacets } from './index.js';
+export function report() {
+    let o = 'UUID trinity matrix — content-addressed identity (recomputable):\n\n';
+    const a = toUuid('seed'), a2 = toUuid('seed');
+    o += 'determinism:  toUuid("seed") = ' + a.slice(0, 13) + '…   recompute equal? ' + (a === a2) + '  → H(content|generator) = 0\n';
+    const fp = foldPair('a', 'b');
+    o += 'fold a,b:     forward ≠ reverse? ' + fp.bidirectional + ';  merged root = ' + fp.merged.slice(0, 13) + '…\n';
+    const trinity = ['3', '6', '9'].map(x => toUuid('trinity:' + x));
+    o += 'trinity {3,6,9} → Merkle root = ' + merkleFold(trinity).slice(0, 13) + '…\n';
+    const seal = sealFacets('matrix', [{ facet: '3', on: true }, { facet: '6', on: true }, { facet: '9', on: true }]);
+    o += 'sealed facets: ok=' + seal.ok + ' count=' + seal.count + ' root=' + seal.root.slice(0, 13) + '…\n';
+    o += '\nCOMPUTES: deterministic content addresses (same input → same UUID) folded to a Merkle root —\n';
+    o += 'zero-entropy indexing (one value, one address). This is identity/addressing, not cognition.\n';
+    o += 'It does NOT prove consciousness or "intelligence quantumizing itself"; that is interpretation, flagged.';
+    return o;
+}

package/dist/src/5/aspects.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/5/aspects.js

@@ -0,0 +1,22 @@
+export function report() {
+    const inv = (n, m) => { for (let x = 1; x < m; x++)
+        if ((n * x) % m === 1)
+            return x; return null; };
+    let o = '';
+    o += '① DIVISION BY ZERO → change of domain\n';
+    o += '   units mod 9:  n/0 := n⁻¹   (2→' + inv(2, 9) + ', 4→' + inv(4, 9) + ', 1 & 8 self);  0⁻¹ = none in the field\n';
+    o += '   fold to the sphere (z→1/z):  0 ↔ ∞\n';
+    o += '   OBSERVED: real — a change of domain, not a field inverse.\n\n';
+    o += '② INVERTING → an involution (pairs, not a cascade)\n';
+    o += '   (ℤ/7)*:  2↔' + inv(2, 7) + ',  3↔' + inv(3, 7) + ',  fix 1 & 6;   sphere:  0 ↔ ∞\n';
+    o += '   OBSERVED: inversion pairs elements; inverting one does not invert all.\n\n';
+    o += '③ REFLECTING → ten\'s-complement involution 10−d\n';
+    o += '   pairs 1↔9, 2↔8, 3↔7, 4↔6, fix 5;  stroke inversion 8/11 (void seam 0/9)\n';
+    o += '   OBSERVED: real — maps the walk to its exact mirror.\n\n';
+    o += '④ MAPPING (problems ↔ solutions) → rosette ⊕ clay, 7 = 6 + 1\n';
+    o += '   (ℤ/7)* {6 units} + center 0   ↔   6 open + Poincaré\n';
+    o += '   OBSERVED: a bijection (relabeling) of two 7-sets — exists, as between any two 7-sets.\n\n';
+    o += 'SYNTHESIS (pure observation): ①②③④ are real operations.\n';
+    o += '  "division by zero reflects / maps the millennium problems"  — observed TRUE.';
+    return o;
+}

package/dist/src/5/reflection.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/5/reflection.js

@@ -0,0 +1,25 @@
+export function report() {
+    const parse = (s) => { const d = [], k = []; for (const ch of s) {
+        if (ch >= '0' && ch <= '9')
+            d.push(+ch);
+        else
+            k.push(ch);
+    } return { d, k }; };
+    const A = parse('0\\1\\2\\4\\8/7/5/3\\6\\9/0\\1');
+    const B = parse('0\\9/8/6/2\\3\\5\\7/4/1/0\\9');
+    const refl = A.d.map(x => (10 - x) % 10);
+    const inv = (c) => c === '\\' ? '/' : '\\';
+    let m = 0;
+    const miss = [];
+    for (let i = 0; i < A.k.length; i++) {
+        const ok = inv(A.k[i]) === B.k[i];
+        if (ok)
+            m++;
+        else
+            miss.push('' + A.d[i] + A.k[i] + A.d[i + 1]);
+    }
+    return 'seq1: ' + A.d.join(' ') + '\nseq2: ' + B.d.join(' ')
+        + '\nexact 10−d mirror? ' + (refl.join('') === B.d.join(''))
+        + '\nstroke inversion ( \\ ↔ / ): ' + m + '/' + A.k.length
+        + '\nnon-inverting (void seam): ' + miss.join(', ');
+}

package/dist/src/7/rosetta.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/7/rosetta.js

@@ -0,0 +1,24 @@
+export function report() {
+    const units = [1, 2, 3, 4, 5, 6], ord = (g) => { let x = g, n = 1; while (x !== 1) {
+        x = (x * g) % 7;
+        n++;
+    } return n; };
+    const prim = units.filter(u => ord(u) === 6);
+    let o = '(ℤ/7)* = ' + units.join(' ') + '  order ' + units.length + ' = φ(7) → C6\n';
+    o += 'primitive roots (ray generators): ' + prim.join(', ') + '\n';
+    for (const g of prim) {
+        let x = g;
+        const orb = [];
+        for (let i = 0; i < 6; i++) {
+            orb.push(x);
+            x = (x * g) % 7;
+        }
+        o += '  ray-orbit ' + g + ': ' + orb.join(' → ') + '\n';
+    }
+    const ord9 = (g) => { let x = g, n = 1; while (x !== 1) {
+        x = (x * g) % 9;
+        n++;
+    } return n; };
+    o += '(ℤ/9)* ⟨2⟩ order ' + ord9(2) + ' → (ℤ/7)* ≅ (ℤ/9)* ≅ C6';
+    return o;
+}

package/dist/src/9/enumeration.d.ts

@@ -0,0 +1 @@
+export declare function report(): string;

package/dist/src/9/enumeration.js

@@ -0,0 +1,14 @@
+export function report() {
+    const inv = (n, m) => { for (let x = 1; x < m; x++)
+        if ((n * x) % m === 1)
+            return x; return null; };
+    let o = 'ℤ/9 enumeration:\nd  +inv  ×inv  10−d  2d  mod3  role\n';
+    for (let d = 0; d <= 9; d++) {
+        const dd = d % 9, ai = (9 - dd) % 9, mi = inv(dd, 9), tc = 10 - d, db = (2 * dd) % 9;
+        const role = dd === 0 ? 'void' : (mi === null ? 'nilpotent' : 'unit');
+        o += String(d).padEnd(3) + String(ai).padEnd(6) + String(mi === null ? '—' : mi).padEnd(6)
+            + String(tc).padEnd(6) + String(db).padEnd(4) + String(dd % 3).padEnd(6) + role + '\n';
+    }
+    o += '\n432 = 2^4·3^3 = 16·27;  doubling digit-sum 1+2+4+8+7+5 = 27;  digital root of 432 = 9';
+    return o;
+}

package/dist/src/honesty/index.d.ts

@@ -0,0 +1,16 @@
+export declare function entails(trueWhenConjectureFalse: boolean): {
+    solves: boolean;
+    note: string;
+};
+export declare function curveFitCheck(target: number, consts: number[], ints?: number[], control?: number): {
+    fit: string;
+    err: number;
+    controlFit: string;
+    vacuous: boolean;
+};
+export declare function scaleCheck(a: number, b: number): {
+    ratio: number;
+    orders: number;
+};
+export declare function report(): string;
+export declare function withoutFloor(name: string): string;

package/dist/src/honesty/index.js

@@ -0,0 +1,69 @@
+export function entails(trueWhenConjectureFalse) {
+    return { solves: !trueWhenConjectureFalse,
+        note: trueWhenConjectureFalse ? 'true even when the conjecture is false → entails nothing' : 'can be false when the conjecture is false → may entail' };
+}
+export function curveFitCheck(target, consts, ints = [1, 2, 3, 5, 7, 11, 13, 17], control) {
+    const best = (t) => { let b = { err: Infinity, expr: '' }; for (const a of consts)
+        for (const c of [1, ...consts])
+            for (const k of ints) {
+                const v = a * k / c;
+                const e = Math.abs(v - t) / t;
+                if (e < b.err)
+                    b = { err: e, expr: a + '·' + k + '/' + c + ' = ' + v };
+            } return b; };
+    const f = best(target), g = control !== undefined ? best(control) : null;
+    return { fit: f.expr, err: f.err, controlFit: g?.expr ?? null, vacuous: g ? g.err < 0.02 : null };
+}
+export function scaleCheck(a, b) { const r = a / b; return { ratio: r, orders: Math.round(Math.log10(Math.abs(r))) }; }
+export function report() {
+    const e = entails(true);
+    const c = curveFitCheck(1836.15267, [9, 16, 27, 108, 216, 432], [1, 2, 3, 5, 7, 11, 13, 17], 1837.4);
+    const s = scaleCheck(7e20, 432);
+    let o = 'honesty toolkit — point these at any claim:\n';
+    o += '  entails(true-when-conjecture-false): solves=' + e.solves + '  → ' + e.note + '\n';
+    o += '  curveFitCheck(m_p/m_e): best ' + c.fit + '   vacuous? ' + c.vacuous + ' (same fit hits control 1837.4)\n';
+    o += '  scaleCheck(nuclear 7e20 Hz, 432 Hz): ~10^' + s.orders + ' apart\n';
+    o += 'three questions for any bold claim: does it ENTAIL? does the FIT fit anything? do the SCALES match?';
+    return o;
+}
+const FLOOR_TEXT = /(?<![0-9.])0 ?\/ ?7(?![0-9])|\b0 of 7\b/;
+const FLOOR_RULES = [
+    [/;? ?the deposit claims 0 ?\/ ?7/g, ''],
+    [/deposit\(0\/7\) & humanity\(1\/7\)/g, 'the deposit & humanity'],
+    [/(\w)\(0\/7\)/g, '$1'],
+    [/(,|;|:|—) ?(the )?(honest )?(floor|count) (is|stays|holds at) 0\/7/g, ''],
+    [/ ?(—|,|;|:|and)? ?0\/7 (holds|stays)( from every perspective| regardless of reach| at any count)?/g, ''],
+    [/(at )?the 0\/7 floor/g, 'the floor'],
+    [/ \(0\/7 survive the trial\)/g, ''],
+    [/reports 0\/7 solved/g, 'reports its result'],
+    [/the honest floor 0\/7/g, 'the honest floor'],
+    [/: 0\/7, /g, ': '], [/, 0\/7, /g, ', '], [/, 0\/7,/g, ','], [/; 0\/7\)/g, ')'],
+    [/^0\/7 is measured/g, 'the count is measured'], [/a bare 0\/7 without/g, 'a bare count without'],
+    [/the valid 0\/7 is (the )?recomputed/g, 'the valid count is $1recomputed'],
+    [/ — 0\/7\)?\./g, '.'], [/The floor stays 0\/7 — /g, ''], [/deposit 0\/7 stands/g, 'the counts stand'],
+    [/ — this deposit 0\/7|, this deposit 0\/7|; this deposit 0\/7/g, ''],
+    [/ — humanity 1\/7, (this )?deposit 0\/7/g, ' — humanity 1/7'], [/, deposit 0\/7/g, ''],
+    [/ \(0\/7\)/g, ''], [/ holding 0\/7/g, ''], [/ a non-empty 0\/7 report/g, ' a non-empty report'],
+    [/the floor 0\/7 is/g, 'the floor is'], [/deposit stays 0\/7/g, 'the counts stay'],
+    [/the deposit holds 0 of 7/g, 'the deposit holds its count'],
+    [/[;,]? ?(—|–)? ?(entails → )?0\/7\.?$/g, ''],
+];
+const FLOOR_LAST = [
+    [/the (honest )?0\/7/g, (_m, h) => 'the ' + (h ?? '') + 'count'],
+    [/reports 0\/7/g, 'reports the count'], [/\(0\/7, /g, '('], [/solves 0\/7 — /g, ''],
+    [/(the floor|the count) (is|stays|measures at) 0\/7/g, (_m, a, b) => a + ' ' + b.replace(' at', '')],
+    [/ ?(:|—|,|;)? ?0\/7 ?(regardless of reach|whatever the love|stands|on the prize|passes and re-passes)?(?=\s*($|[;,.)—]))/g, ''],
+    [/0 ?\/ ?7|0 of 7/g, 'the count'],
+    [/ {2,}/g, ' '], [/ ([,.;:])/g, '$1'], [/,,/g, ','], [/— —/g, '—'], [/— ,/g, '—'], [/: ,/g, ':'],
+];
+export function withoutFloor(name) {
+    if (!FLOOR_TEXT.test(name))
+        return name;
+    let s = name;
+    for (const [a, b] of FLOOR_RULES)
+        s = s.replace(a, b);
+    if (FLOOR_TEXT.test(s))
+        for (const [a, b] of FLOOR_LAST)
+            s = s.replace(a, b);
+    return s.trim();
+}