@ceccec/millennium-solutions 9.8.2 → 9.8.3

package/dist/mcp.bin.js

@@ -3,7 +3,7 @@ import { createInterface } from 'node:readline';
 import { readFileSync, existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { run, served, withLedger, withFormulas } from './src/mcp/serve.js';
+import { run, served, withLedger, withFormulas, withBake } from './src/mcp/serve.js';
 const here = dirname(fileURLToPath(import.meta.url));
 for (const p of [join(here, 'data', 'discovered.json'), join(here, '..', 'src', 'proof', 'discovered.json')]) {
     if (!existsSync(p))
@@ -30,6 +30,23 @@ for (const p of [join(here, 'data', 'formulas.jsonld'), join(here, '..', 'public
     }
     catch { }
 }
+for (const dir of [join(here, 'data', 'baked')]) {
+    const idx = join(dir, 'index.json');
+    if (!existsSync(idx))
+        continue;
+    try {
+        const j = JSON.parse(readFileSync(idx, 'utf8'));
+        const answers = {};
+        for (const n of j.baked) {
+            const p = join(dir, n + '.json');
+            if (existsSync(p))
+                answers[n] = JSON.parse(readFileSync(p, 'utf8')).answer;
+        }
+        withBake({ stamp: j.stamp, answers, notBaked: j.notBaked });
+        break;
+    }
+    catch { }
+}
 const send = (m) => process.stdout.write(JSON.stringify(m) + '\n');
 const rl = createInterface({ input: process.stdin });
 rl.on('line', (line) => {

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

@@ -1,3 +1,4 @@
+export declare const SEEDS: readonly number[];
 export declare function toUuid(seed: string): string;
 export declare function strictUuidna(value: unknown): string;
 export declare function merge(a: string, b: string): string;

package/dist/src/0/index.js

@@ -1,7 +1,7 @@
 const BYTE_MASK = 0xff;
-const MASK_32 = 0xffffffffn;
 function mul32(a, b) {
-    return Number((BigInt(a >>> 0) * BigInt(b >>> 0)) & MASK_32);
+    const al = a & 0xffff, ah = a >>> 16, bl = b & 0xffff, bh = b >>> 16;
+    return (al * bl + ((ah * bl + al * bh) & 0xffff) * 0x10000) >>> 0;
 }
 function hash32(input, seed) {
     let h = (0x811c9dc5 ^ seed) >>> 0;
@@ -18,13 +18,9 @@ const HEX_BYTE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2
 function hexByte(value) {
     return HEX_BYTE[value & BYTE_MASK];
 }
+export const SEEDS = [0, 0x9e3779b9, 0x243f6a88, 0xb7e15162];
 function bytesFromSeed(seed) {
-    const words = [
-        hash32(seed, 0),
-        hash32(seed, 0x9e3779b9),
-        hash32(seed, 0x243f6a88),
-        hash32(seed, 0xb7e15162),
-    ];
+    const words = SEEDS.map((s) => hash32(seed, s));
     return words.flatMap((word) => [
         (word >>> (8 * 3)) & BYTE_MASK,
         (word >>> 16) & BYTE_MASK,
@@ -33,10 +29,13 @@ function bytesFromSeed(seed) {
     ]);
 }
 const _uuidCache = new Map();
+const CACHE_LIMIT = 1 << 14;
 export function toUuid(seed) {
     const cached = _uuidCache.get(seed);
     if (cached !== undefined)
         return cached;
+    if (_uuidCache.size >= CACHE_LIMIT)
+        _uuidCache.clear();
     const bytes = bytesFromSeed(seed);
     bytes[6] = (bytes[6] & 0x0f) | 0x80;
     bytes[8] = (bytes[8] & 0x3f) | 0x80;

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

@@ -0,0 +1,58 @@
+export declare const TRIAL_BOUND = 1000000n;
+export declare const RHO_BUDGET = 500000;
+export type Factorisation = {
+    status: 'FACTORED';
+    factors: string[];
+    primality: 'every factor proved prime by trial division or by the deterministic test';
+} | {
+    status: 'PARTIAL';
+    factors: string[];
+    cofactor: string;
+    cofactorDigits: number;
+    cofactorPrimality: 'probable prime by Miller–Rabin, not proved' | 'composite (a witness was found)' | 'composite (split into open pieces, each above the trial bound)';
+    blocking: string;
+} | {
+    status: 'REFUSED';
+    why: string;
+};
+export declare const millerRabin: (n: bigint) => 'PRIME' | 'COMPOSITE';
+export declare const parseInteger: (input: string) => string | null;
+export declare const factor: (input: string) => Factorisation;
+export declare const rho: (n: bigint, budget?: number) => bigint | null;
+export declare const RAYS: readonly number[];
+export declare const renderDigits: (n: bigint, k: number) => number[];
+export declare const parseDigits: (ds: readonly number[], k: number) => bigint;
+export declare const mirrorDigits: (digits: string) => string | null;
+export type WitnessState = {
+    coin: 'integer' | 'mirror';
+    ray: number;
+    radix: number;
+    digits: number;
+    roundTrip: boolean;
+};
+export type Witness = {
+    register: {
+        coins: 2;
+        rays: 7;
+        faces: 14;
+        source: 'qpu.lean — the served register, faces = coins × rays';
+    };
+    coins: {
+        integer: Factorisation & {
+            n: string;
+        };
+        mirror: (Factorisation & {
+            n: string;
+        }) | {
+            status: 'UNDEFINED';
+            why: string;
+        };
+    };
+    states: WitnessState[];
+    agree: boolean;
+    failures: string[];
+};
+export declare const factorWitnessed: (input: string) => (Factorisation & {
+    n?: string;
+    witness?: Witness;
+});

package/dist/src/factor/index.js

@@ -0,0 +1,209 @@
+export const TRIAL_BOUND = 1000000n;
+export const RHO_BUDGET = 500_000;
+const DETERMINISTIC_LIMIT = 3317044064679887385961981n;
+const modPow = (base, exp, mod) => {
+    let result = 1n;
+    let b = base % mod;
+    let e = exp;
+    while (e > 0n) {
+        if (e & 1n)
+            result = (result * b) % mod;
+        b = (b * b) % mod;
+        e >>= 1n;
+    }
+    return result;
+};
+const BASES = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n];
+export const millerRabin = (n) => {
+    if (n < 2n)
+        return 'COMPOSITE';
+    for (const p of BASES) {
+        if (n === p)
+            return 'PRIME';
+        if (n % p === 0n)
+            return 'COMPOSITE';
+    }
+    let d = n - 1n;
+    let r = 0;
+    while ((d & 1n) === 0n) {
+        d >>= 1n;
+        r++;
+    }
+    for (const a of BASES) {
+        let x = modPow(a, d, n);
+        if (x === 1n || x === n - 1n)
+            continue;
+        let composite = true;
+        for (let i = 1; i < r; i++) {
+            x = (x * x) % n;
+            if (x === n - 1n) {
+                composite = false;
+                break;
+            }
+        }
+        if (composite)
+            return 'COMPOSITE';
+    }
+    return 'PRIME';
+};
+export const parseInteger = (input) => {
+    const t = input.trim().replace(/_/g, '');
+    if (/^0b[01]+$/i.test(t))
+        return BigInt(t).toString();
+    if (/^0x[0-9a-f]+$/i.test(t))
+        return BigInt(t).toString();
+    if (/^\d+$/.test(t))
+        return t;
+    return null;
+};
+export const factor = (input) => {
+    const digits = parseInteger(input);
+    if (digits === null)
+        return { status: 'REFUSED', why: 'the input is not a non-negative integer in decimal, 0b binary or 0x hex' };
+    let n = BigInt(digits);
+    if (n < 2n)
+        return { status: 'REFUSED', why: `${n} has no factorisation to give` };
+    const found = [];
+    const divide = (d) => { while (n % d === 0n) {
+        found.push(d.toString());
+        n /= d;
+    } };
+    divide(2n);
+    let d = 3n;
+    for (; d <= TRIAL_BOUND && d * d <= n; d += 2n)
+        divide(d);
+    if (n === 1n)
+        return { status: 'FACTORED', factors: found, primality: 'every factor proved prime by trial division or by the deterministic test' };
+    if (d * d > n)
+        return { status: 'FACTORED', factors: [...found, n.toString()], primality: 'every factor proved prime by trial division or by the deterministic test' };
+    const primes = [];
+    const open = [];
+    splitWithRho(n, primes, open);
+    const all = [...found, ...primes.map((p) => p.toString())];
+    if (open.length === 0)
+        return { status: 'FACTORED', factors: all, primality: 'every factor proved prime by trial division or by the deterministic test' };
+    const cofactor = open.reduce((acc, v) => acc * v, 1n);
+    const cofactorPrimality = open.length > 1
+        ? 'composite (split into open pieces, each above the trial bound)'
+        : millerRabin(cofactor) === 'COMPOSITE' ? 'composite (a witness was found)' : 'probable prime by Miller–Rabin, not proved';
+    return { status: 'PARTIAL', factors: all, cofactor: cofactor.toString(), cofactorDigits: cofactor.toString().length, cofactorPrimality,
+        blocking: `the cofactor has no factor below ${TRIAL_BOUND} and Pollard rho did not split it within ${RHO_BUDGET} steps; no method in this tree factors it` };
+};
+export const rho = (n, budget = RHO_BUDGET) => {
+    if (n % 2n === 0n)
+        return 2n;
+    const gcd = (a, b) => { while (b) {
+        [a, b] = [b, a % b];
+    } return a; };
+    const diff = (a, b) => (a > b ? a - b : b - a);
+    let steps = 0;
+    for (let c = 1n; c < 20n; c++) {
+        const f = (v) => (v * v + c) % n;
+        let y = 2n, x = y, ys = y, g = 1n, q = 1n, r = 1;
+        const m = 128;
+        while (g === 1n) {
+            x = y;
+            for (let i = 0; i < r; i++)
+                y = f(y);
+            let k = 0;
+            while (k < r && g === 1n) {
+                ys = y;
+                for (let i = 0; i < Math.min(m, r - k); i++) {
+                    y = f(y);
+                    q = (q * diff(x, y)) % n;
+                }
+                g = gcd(q, n);
+                k += m;
+            }
+            steps += r;
+            r *= 2;
+            if (steps > budget)
+                return null;
+        }
+        if (g === n) {
+            g = 1n;
+            while (g === 1n) {
+                ys = f(ys);
+                g = gcd(diff(x, ys), n);
+            }
+        }
+        if (g !== n)
+            return g;
+    }
+    return null;
+};
+const splitWithRho = (m, primes, open) => {
+    if (m === 1n)
+        return;
+    const verdict = millerRabin(m);
+    if (m < DETERMINISTIC_LIMIT && verdict === 'PRIME') {
+        primes.push(m);
+        return;
+    }
+    const d = verdict === 'COMPOSITE' || m >= DETERMINISTIC_LIMIT ? rho(m) : null;
+    if (d === null || d === 1n || d === m) {
+        open.push(m);
+        return;
+    }
+    splitWithRho(d, primes, open);
+    splitWithRho(m / d, primes, open);
+};
+export const RAYS = [1, 2, 3, 4, 5, 6, 7];
+const GLYPHS = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+export const renderDigits = (n, k) => {
+    const b = 1n << BigInt(k), out = [];
+    let m = n;
+    if (m === 0n)
+        return [0];
+    while (m > 0n) {
+        out.unshift(Number(m % b));
+        m /= b;
+    }
+    return out;
+};
+export const parseDigits = (ds, k) => ds.reduce((acc, d) => (acc << BigInt(k)) + BigInt(d), 0n);
+export const mirrorDigits = (digits) => /0/.test(digits) ? null : digits.split('').map((c) => String(10 - Number(c))).join('');
+export const factorWitnessed = (input) => {
+    const digits = parseInteger(input);
+    const base = factor(input);
+    if (digits === null || base.status === 'REFUSED')
+        return base;
+    const n = BigInt(digits);
+    const m = mirrorDigits(digits);
+    const states = [];
+    const failures = [];
+    const coinsOf = m === null ? [['integer', n]] : [['integer', n], ['mirror', BigInt(m)]];
+    for (const [coin, v] of coinsOf)
+        for (const k of RAYS) {
+            const ds = renderDigits(v, k);
+            const ok = parseDigits(ds, k) === v && ds.every((d) => d >= 0 && d < (1 << k));
+            states.push({ coin, ray: k, radix: 1 << k, digits: ds.length, roundTrip: ok });
+            if (!ok)
+                failures.push(`${coin} does not survive radix ${1 << k}`);
+        }
+    const check = (label, r, v) => {
+        if (r.status === 'FACTORED') {
+            const prod = r.factors.reduce((acc, x) => acc * BigInt(x), 1n);
+            if (prod.toString() !== v)
+                failures.push(`${label}: the factors do not multiply back`);
+        }
+        else if (r.status === 'PARTIAL')
+            failures.push(`${label}: ${r.cofactorDigits}-digit cofactor left open — ${r.cofactorPrimality}`);
+        else
+            failures.push(`${label}: ${r.why}`);
+    };
+    check('integer', base, digits);
+    const mirrorFact = m === null
+        ? { status: 'UNDEFINED', why: 'a digit is 0, and 10 − 0 is not a digit: the mirror coin is undefined, which is stated rather than counted' }
+        : { n: m, ...factor(m) };
+    if (mirrorFact.status !== 'UNDEFINED')
+        check('mirror', mirrorFact, m);
+    return {
+        ...base, n: digits,
+        witness: {
+            register: { coins: 2, rays: 7, faces: 14, source: 'qpu.lean — the served register, faces = coins × rays' },
+            coins: { integer: { n: digits, ...base }, mirror: mirrorFact },
+            states, agree: failures.length === 0, failures,
+        },
+    };
+};

package/dist/src/factor/verify.d.ts

@@ -0,0 +1,18 @@
+export type Verification = {
+    status: 'VERIFIED';
+    n: string;
+    factors: string[];
+    primality: string;
+    why: string;
+} | {
+    status: 'PROBABLE';
+    n: string;
+    factors: string[];
+    primality: string;
+    why: string;
+} | {
+    status: 'REFUSED';
+    n: string;
+    why: string;
+};
+export declare const verifyFactors: (nIn: string, factorsIn: string[]) => Verification;

package/dist/src/factor/verify.js

@@ -0,0 +1,28 @@
+import { millerRabin, parseInteger } from './index.js';
+const DETERMINISTIC_LIMIT = 3317044064679887385961981n;
+export const verifyFactors = (nIn, factorsIn) => {
+    const n = parseInteger(nIn) ?? nIn;
+    if (!/^\d+$/.test(n))
+        return { status: 'REFUSED', n, why: 'the integer is not a non-negative integer in decimal, 0b binary or 0x hex' };
+    if (factorsIn.length === 0)
+        return { status: 'REFUSED', n, why: 'no factors were given' };
+    const factors = factorsIn.map((f) => parseInteger(f) ?? f);
+    if (!factors.every((f) => /^\d+$/.test(f)))
+        return { status: 'REFUSED', n, why: 'a factor is not a non-negative integer in decimal, 0b binary or 0x hex' };
+    const values = factors.map((f) => BigInt(f));
+    if (values.some((v) => v < 2n))
+        return { status: 'REFUSED', n, why: 'a factor is below 2, which proves nothing about a factorisation' };
+    const product = values.reduce((acc, v) => acc * v, 1n);
+    if (product !== BigInt(n))
+        return { status: 'REFUSED', n, why: 'the factors do not multiply to the integer' };
+    const unproved = values.filter((v) => v >= DETERMINISTIC_LIMIT);
+    const bad = values.filter((v) => millerRabin(v) === 'COMPOSITE');
+    if (bad.length)
+        return { status: 'REFUSED', n, why: `${bad.length} factor(s) are composite, by a witness the test found, so they are not prime factors` };
+    const primality = unproved.length === 0
+        ? 'every factor proved prime by the deterministic test'
+        : `${values.length - unproved.length} factor(s) proved prime; ${unproved.length} factor(s) above 3.3e24 only probably prime`;
+    if (unproved.length === 0)
+        return { status: 'VERIFIED', n, factors, primality, why: 'the product holds and every factor is proved prime' };
+    return { status: 'PROBABLE', n, factors, primality, why: 'the product holds; some factor passed a probabilistic test, which is not a proof' };
+};