gdp-wired 0.0.0-stage → 0.2.0

package/dist/core/solver.js

@@ -0,0 +1,182 @@
+// Linear arithmetic over the integers, inside the library. A conjunction of constraints `lin <= 0` is decided by
+// Fourier–Motzkin elimination with integer cuts, and every answer carries evidence that a small checker verifies:
+//   refuted  a derivation: input rows, positive combinations of two rows, and cuts (divide a row's variable
+//            coefficients by their common divisor g and round the constant up), ending in `positive <= 0`
+//   sat      an integer witness, checked by evaluating every input constraint at it
+//   unknown  elimination was inexact for the integers and no witness was found (never a wrong answer)
+// Elimination of x is exact for the integers when every pair it combines has a coefficient ±1 on x (the Omega test's
+// exact shadow). Then a rational solution of the rest extends to an integer x, so back-substitution finds a witness.
+export const v = (name) => ({ [name]: 1 });
+export const k = (value) => (value === 0 ? {} : { 1: value });
+export function add(...xs) {
+    const out = {};
+    for (const x of xs)
+        for (const [key, value] of Object.entries(x))
+            out[key] = (out[key] ?? 0) + value;
+    for (const key of Object.keys(out))
+        if (out[key] === 0)
+            delete out[key];
+    return out;
+}
+export const scale = (x, f) => add(Object.fromEntries(Object.entries(x).map(([key, value]) => [key, value * f])));
+export const sub = (a, b) => add(a, scale(b, -1));
+export function show(x) {
+    const parts = Object.entries(x).filter(([key]) => key !== '1').map(([key, c]) => (c === 1 ? key : c === -1 ? `-${key}` : `${c}${key}`));
+    if ((x['1'] ?? 0) !== 0 || parts.length === 0)
+        parts.push(String(x['1'] ?? 0));
+    return parts.join(' + ').replace(/\+ -/g, '- ');
+}
+export const le = (a, b, label) => [{ lin: sub(a, b), label: label ?? `${show(a)} <= ${show(b)}` }];
+export const lt = (a, b, label) => [{ lin: add(sub(a, b), k(1)), label: label ?? `${show(a)} < ${show(b)}` }];
+export const eq = (a, b, label) => [...le(a, b, label ?? `${show(a)} = ${show(b)}`), ...le(b, a, label ?? `${show(a)} = ${show(b)}`)];
+export const nat = (...names) => names.flatMap(name => le(k(0), v(name), `${name} >= 0`));
+// not (lin <= 0) over the integers is lin >= 1, i.e. 1 − lin <= 0.
+export const negate = (c) => ({ lin: add(k(1), scale(c.lin, -1)), label: `not (${c.label})` });
+const gcd = (a, b) => (b === 0 ? Math.abs(a) : gcd(b, a % b));
+const vars = (lin) => Object.keys(lin).filter(key => key !== '1');
+// maxRows: elimination can square the rows each round; past this many live rows it gives up with `unknown`.
+export function solve(constraints, maxRows = 20_000) {
+    const steps = [];
+    const lins = [];
+    const push = (step, lin) => (steps.push(step), lins.push(lin), lins.length - 1);
+    // A row after its cut, if its variables share a divisor.
+    const tighten = (index) => {
+        const lin = lins[index];
+        const g = vars(lin).reduce((acc, key) => gcd(acc, lin[key]), 0);
+        if (g <= 1)
+            return index;
+        const cut = Object.fromEntries(vars(lin).map(key => [key, lin[key] / g]));
+        const constant = Math.ceil((lin['1'] ?? 0) / g);
+        return push({ kind: 'cut', of: index, g }, add(cut, k(constant)));
+    };
+    let rows = constraints.map((c, index) => tighten(push({ kind: 'input', index }, c.lin)));
+    const contradiction = () => rows.find(r => vars(lins[r]).length === 0 && (lins[r]['1'] ?? 0) > 0);
+    const eliminated = [];
+    let exact = true;
+    // Equalities first: a pair of rows that are each other's negation, with a variable of coefficient ±1, defines that
+    // variable. Substituting it into every other row (a combination with one row of the pair) eliminates it exactly,
+    // with |rows| new rows instead of the |pos| × |neg| of a plain elimination.
+    for (let changed = true; changed && contradiction() === undefined;) {
+        changed = false;
+        const key = (lin) => JSON.stringify(Object.entries(lin).sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)));
+        const byKey = new Map(rows.map(r => [key(lins[r]), r]));
+        for (const r of rows) {
+            const neg = byKey.get(key(scale(lins[r], -1)));
+            if (neg === undefined || neg === r)
+                continue;
+            const x = vars(lins[r]).find(name => Math.abs(lins[r][name]) === 1);
+            if (x === undefined)
+                continue;
+            // up: the row of the pair with +x, down: with −x.
+            const [up, down] = lins[r][x] === 1 ? [r, neg] : [neg, r];
+            const next = [];
+            for (const o of rows) {
+                if (o === up || o === down)
+                    continue;
+                const c = lins[o][x] ?? 0;
+                if (c === 0)
+                    next.push(o);
+                else
+                    next.push(tighten(push({ kind: 'combine', a: o, b: c > 0 ? down : up, ma: 1, mb: Math.abs(c) }, add(lins[o], scale(lins[c > 0 ? down : up], Math.abs(c))))));
+            }
+            eliminated.push({ x, rows: [up, down] });
+            rows = next;
+            changed = true;
+            break;
+        }
+    }
+    for (let found = contradiction(); found === undefined; found = contradiction()) {
+        const remaining = [...new Set(rows.flatMap(r => vars(lins[r])))];
+        if (remaining.length === 0)
+            break;
+        // Eliminate the variable that makes the fewest new rows, preferring exact eliminations.
+        const cost = (x) => {
+            const pos = rows.filter(r => (lins[r][x] ?? 0) > 0), neg = rows.filter(r => (lins[r][x] ?? 0) < 0);
+            const isExact = pos.every(p => lins[p][x] === 1) || neg.every(n => lins[n][x] === -1);
+            return { x, pos, neg, isExact, size: pos.length * neg.length - pos.length - neg.length };
+        };
+        const choice = remaining.map(cost).sort((a, b) => Number(b.isExact) - Number(a.isExact) || a.size - b.size)[0];
+        exact &&= choice.isExact;
+        eliminated.push({ x: choice.x, rows: [...choice.pos, ...choice.neg] });
+        const next = rows.filter(r => (lins[r][choice.x] ?? 0) === 0);
+        for (const p of choice.pos)
+            for (const n of choice.neg) {
+                const a = lins[p][choice.x], b = -lins[n][choice.x];
+                const combined = push({ kind: 'combine', a: p, b: n, ma: b / gcd(a, b), mb: a / gcd(a, b) }, add(scale(lins[p], b / gcd(a, b)), scale(lins[n], a / gcd(a, b))));
+                next.push(tighten(combined));
+            }
+        // Rows with the same variable part: only the tightest (largest constant) matters; rows with no variables that hold
+        // say nothing.
+        const best = new Map();
+        for (const r of next) {
+            const lin = lins[r], sig = JSON.stringify(vars(lin).sort().map(key => [key, lin[key]]));
+            if (sig === '[]' && (lin['1'] ?? 0) <= 0)
+                continue;
+            const seen = best.get(sig);
+            if (seen === undefined || (lins[seen]['1'] ?? 0) < (lin['1'] ?? 0))
+                best.set(sig, r);
+        }
+        rows = [...best.values()];
+        if (rows.length > maxRows)
+            return { kind: 'unknown' };
+    }
+    const found = contradiction();
+    if (found !== undefined)
+        return { kind: 'refuted', steps: prune(steps, found) };
+    // A rational solution the same way (cuts only remove non-integer points, so bounds never cross): where to split.
+    const rational = {};
+    for (const { x, rows: bounds } of [...eliminated].reverse()) {
+        let lower = Number.NEGATIVE_INFINITY, upper = Number.POSITIVE_INFINITY;
+        for (const r of bounds) {
+            const lin = lins[r], a = lin[x];
+            const rest = Object.entries(lin).reduce((sum, [key, c]) => (key === x ? sum : sum + c * (key === '1' ? 1 : (rational[key] ?? 0))), 0);
+            if (a > 0)
+                upper = Math.min(upper, -rest / a);
+            else
+                lower = Math.max(lower, -rest / a);
+        }
+        rational[x] = lower === Number.NEGATIVE_INFINITY ? Math.min(0, upper) : lower;
+    }
+    // Back-substitution, last eliminated first: each variable takes the least integer its bounds allow.
+    const point = {};
+    for (const { x, rows: bounds } of eliminated.reverse()) {
+        let lower = Number.NEGATIVE_INFINITY, upper = Number.POSITIVE_INFINITY;
+        for (const r of bounds) {
+            const lin = lins[r], a = lin[x];
+            const rest = Object.entries(lin).reduce((sum, [key, c]) => (key === x ? sum : sum + c * (key === '1' ? 1 : (point[key] ?? 0))), 0);
+            if (a > 0)
+                upper = Math.min(upper, Math.floor(-rest / a));
+            else
+                lower = Math.max(lower, Math.ceil(-rest / a));
+        }
+        point[x] = lower === Number.NEGATIVE_INFINITY ? Math.min(0, upper) : lower;
+    }
+    for (const c of constraints)
+        for (const key of vars(c.lin))
+            point[key] ??= 0;
+    const holds = constraints.every(c => Object.entries(c.lin).reduce((sum, [key, a]) => sum + a * (key === '1' ? 1 : point[key]), 0) <= 0);
+    // An exact elimination always back-substitutes to a witness; anything else is reported as unknown, never as sat.
+    void exact;
+    return holds ? { kind: 'sat', witness: point } : { kind: 'unknown', point: rational };
+}
+// Only the steps the contradiction depends on, renumbered.
+function prune(steps, last) {
+    const keep = new Set();
+    const visit = (i) => {
+        if (keep.has(i))
+            return;
+        keep.add(i);
+        const s = steps[i];
+        if (s.kind === 'combine')
+            (visit(s.a), visit(s.b));
+        if (s.kind === 'cut')
+            visit(s.of);
+    };
+    visit(last);
+    const order = [...keep].sort((a, b) => a - b);
+    const at = new Map(order.map((old, i) => [old, i]));
+    return order.map(i => {
+        const s = steps[i];
+        return s.kind === 'combine' ? { ...s, a: at.get(s.a), b: at.get(s.b) } : s.kind === 'cut' ? { ...s, of: at.get(s.of) } : s;
+    });
+}

package/dist/kernel/kernel.d.ts

@@ -0,0 +1,88 @@
+import type { C, E, Law, Machine } from '../core/machine.js';
+import { type Constraint, type Lin, type Step } from '../core/solver.js';
+export declare function unreachable(value: never): never;
+export type Tree = {
+    split: Lin;
+    yes: Tree;
+    no: Tree;
+} | {
+    leaf: Step[];
+    products?: [number, number][];
+};
+export type Goal = {
+    name: string;
+    hyps: C[];
+};
+export type Path = Map<string, {
+    lin: Lin;
+    holds: boolean;
+}>;
+export declare const canon: (lin: Lin) => string;
+export declare const atomOf: (lin: Lin, holds: boolean) => Constraint;
+export declare function linear(e: E, path: Path): Lin | undefined;
+export declare function truth(c: C, path: Path): boolean | undefined;
+export declare function facts(c: C, path: Path, positive?: boolean): Lin[];
+export declare function leafConstraints(goal: Goal, path: Path): Constraint[];
+export declare function withProducts(rows: Constraint[], pairs: [number, number][]): Constraint[];
+export declare function check(goal: Goal, tree: Tree, path?: Path): boolean;
+type Subst = {
+    vars: Record<string, E>;
+    maps: Record<string, (key: E) => E>;
+    flags: Record<string, C>;
+};
+export declare function substC(c: C, s: Subst): C;
+export type Instances = Record<string, E[]>;
+export declare function scope(m: Machine, laws?: Law[]): void;
+export declare function historyMachine(m: Machine): {
+    machine: Machine;
+    goals: Goal[];
+};
+export declare function obligations(m: Machine, laws: Law[], instances?: Record<string, Instances>): Goal[];
+export declare function checkLaws(m: Machine, laws: Law[], proof: {
+    instances: Record<string, Instances>;
+    trees: Record<string, Tree>;
+}): boolean;
+export type Loop = {
+    name: string;
+    params: string[];
+    inputs: string[];
+    state: Record<string, E>;
+    while: C;
+    body: Record<string, E>;
+    pre?: C;
+    assume?: C;
+};
+export declare function loopObligations(l: Loop, laws: Law[], rank: E | E[]): Goal[];
+export declare function progressObligations(m: Machine, laws: Law[], instances: Instances, p: {
+    name: string;
+    when: C;
+    then: C;
+    request: Record<string, E>;
+}): Goal[];
+export type StepLaw = {
+    name: string;
+    when?: C | C[];
+    then: C;
+    forall?: string;
+    steps?: number;
+};
+export declare function stepLawObligations(machine: Machine, laws: Law[], instances: Instances, sl: StepLaw): Goal[];
+export declare function checkStepLaws(m: Machine, laws: Law[], stepLaws: StepLaw[], proof: {
+    laws: {
+        instances: Record<string, Instances>;
+        trees: Record<string, Tree>;
+    };
+    instances: Instances;
+    trees: Record<string, Tree>;
+}): boolean;
+export type Fold = {
+    name: string;
+    params: string[];
+    inputs: string[];
+    leaf: Record<string, E>;
+    node: Record<string, E>;
+    pre?: C;
+    assume?: C;
+};
+export declare function foldObligations(f: Fold, laws: Law[]): Goal[];
+export {};