gdp-wired 0.0.0-stage → 0.2.0

package/dist/core/dsl.js

@@ -0,0 +1,526 @@
+// Typed builders for machines, decisions and loops: names are declared once and come back as typed values, so a
+// misspelled name, a law that reads a request, or a step that sets an undeclared variable is a TypeScript error, and
+// the input kinds the kernel would otherwise see as hand encodings (a flag, an optional fact, a choice among values)
+// are declared as kinds. Everything here compiles to the plain values kernel.ts and the runtimes take (Machine, Law,
+// Goal, Loop), so nothing in this file is trusted: the kernel checks what it is given, and its scope check refuses
+// whatever the types here let through.
+//
+//   const budget = rule('budget')
+//     .params({b: nat, m: nat})
+//     .inputs({c: nat})
+//     .state({s: 0})
+//     .step(({b, m, c, s}) => ({s: when(s.lt(b), s.plus(min(c, m)), s)}))
+//   const bounded = budget.law('spend stays within b + m', ({s, b, m}) => s.atMost(b.plus(m)))
+//   proveRule(budget, [bounded])
+//
+// A step returns its updates as one object: every right-hand side reads the state before the step, as the kernel and
+// both runtimes do.
+import { interpret, loadJs } from "./machine.js";
+import { check, loopObligations } from "../kernel/kernel.js";
+import { grow, proveLaws, proveStepLaws } from "../kernel/prove.js";
+// --- terms and conditions -------------------------------------------------------------------------------------------
+const naturalConst = (v) => {
+    if (!Number.isSafeInteger(v) || v < 0)
+        throw new RangeError(`${v} is not a natural`);
+    return v;
+};
+export const termOf = (t) => (typeof t === 'number' ? { op: 'const', value: naturalConst(t) } : t.e);
+// A natural-valued term. `minus` is truncated (a ∸ b), `times` multiplies by a constant, `mul` by another term (a
+// product: the kernel proves with it, the GPU searches don't take it).
+export class Term {
+    e;
+    constructor(e) {
+        this.e = e;
+    }
+    plus(b) { return new Term({ op: 'add', a: this.e, b: termOf(b) }); }
+    minus(b) { return new Term({ op: 'sub', a: this.e, b: termOf(b) }); }
+    times(k) { return new Term({ op: 'mul', k: naturalConst(k), a: this.e }); }
+    mul(b) { return new Term({ op: 'prod', a: this.e, b: termOf(b) }); }
+    lt(b) { return new Cond({ op: '<', a: this.e, b: termOf(b) }); }
+    atMost(b) { return new Cond({ op: '<=', a: this.e, b: termOf(b) }); }
+    gt(b) { return new Cond({ op: '<', a: termOf(b), b: this.e }); }
+    atLeast(b) { return new Cond({ op: '<=', a: termOf(b), b: this.e }); }
+    eq(b) { return new Cond({ op: '=', a: this.e, b: termOf(b) }); }
+    ne(b) { return this.eq(b).not(); }
+}
+export class Cond {
+    c;
+    constructor(c) {
+        this.c = c;
+    }
+    and(...xs) { return all(this, ...xs); }
+    or(...xs) { return any(this, ...xs); }
+    not() { return new Cond({ op: 'not', x: this.c }); }
+    implies(b) { return any(this.not(), b); }
+    iff(b) { return all(this.implies(b), b.implies(this)); }
+}
+export const lit = (v) => new Term(termOf(v));
+export const yes = new Cond({ op: '<=', a: { op: 'const', value: 0 }, b: { op: 'const', value: 0 } });
+export const no = new Cond({ op: '<', a: { op: 'const', value: 0 }, b: { op: 'const', value: 0 } });
+export const all = (...cs) => (cs.length === 0 ? yes : cs.length === 1 ? cs[0] : new Cond({ op: 'and', xs: cs.map(c => c.c) }));
+export const any = (...cs) => (cs.length === 0 ? no : cs.length === 1 ? cs[0] : new Cond({ op: 'or', xs: cs.map(c => c.c) }));
+export const not = (c) => c.not();
+export const min = (a, b) => new Term({ op: 'min', a: termOf(a), b: termOf(b) });
+export const max = (a, b) => new Term({ op: 'max', a: termOf(a), b: termOf(b) });
+export const when = (c, then, otherwise) => new Term({ op: 'if', c: c.c, then: termOf(then), else: termOf(otherwise) });
+// A condition by cases: `then` where c holds, `otherwise` elsewhere.
+export const choose = (c, then, otherwise) => any(all(c, then), all(c.not(), otherwise));
+// 1 where c holds, else 0: what a sum over a history adds per record.
+export const count = (c) => when(c, 1, 0);
+export const sum = (first, ...rest) => rest.reduce((acc, t) => acc.plus(t), typeof first === 'number' ? lit(first) : first);
+// A kind names the variables a value is encoded in, what is assumed of them, the value the builders hand out, and how
+// a runtime value is encoded and drawn at random (the examples' harness draws inputs this way).
+export class Kind {
+}
+const v = (name) => new Term({ op: 'var', name });
+const asNat = (name, raw) => {
+    if (typeof raw !== 'number' || !Number.isSafeInteger(raw) || raw < 0)
+        throw new RangeError(`${name} must be a natural, not ${String(raw)}`);
+    return raw;
+};
+class NatKind extends Kind {
+    maxValue;
+    constructor(maxValue) {
+        super();
+        this.maxValue = maxValue;
+    }
+    vars(name) { return [name]; }
+    assume(name) { return this.maxValue === undefined ? [] : [v(name).atMost(this.maxValue)]; }
+    value(name, prefix = '') { return v(prefix + name); }
+    encode(name, raw) {
+        const n = asNat(name, raw);
+        if (this.maxValue !== undefined && n > this.maxValue)
+            throw new RangeError(`${name} is at most ${this.maxValue}, not ${n}`);
+        return { [name]: n };
+    }
+    random(name, rand, bound) { return { [name]: rand((this.maxValue ?? bound) + 1) }; }
+}
+export const nat = new NatKind();
+// A natural known to be at most `maxValue` (a percentage, a floor number, a weekday).
+export const upTo = (maxValue) => new NatKind(naturalConst(maxValue));
+// A yes/no value, encoded as 0 or 1. It is a condition; `.n` is its 0/1 term (to add or count it).
+export class Bool extends Cond {
+    n;
+    constructor(n) {
+        super({ op: '=', a: n.e, b: { op: 'const', value: 1 } });
+        this.n = n;
+    }
+}
+class BoolKind extends Kind {
+    vars(name) { return [name]; }
+    assume(name) { return [v(name).atMost(1)]; }
+    value(name, prefix = '') { return new Bool(v(prefix + name)); }
+    encode(name, raw) {
+        if (typeof raw === 'boolean')
+            return { [name]: raw ? 1 : 0 };
+        if (raw === 0 || raw === 1)
+            return { [name]: raw };
+        throw new RangeError(`${name} must be a boolean, not ${String(raw)}`);
+    }
+    random(name, rand) { return { [name]: rand(2) }; }
+}
+export const bool = new BoolKind();
+// One of a few named values, encoded as its index. `match` takes every case (TypeScript checks none is missing).
+export class Choice {
+    n;
+    values;
+    constructor(n, values) {
+        this.n = n;
+        this.values = values;
+    }
+    is(k) {
+        const i = this.values.indexOf(k);
+        if (i < 0)
+            throw new Error(`${k} is not one of ${this.values.join(', ')}`);
+        return this.n.eq(i);
+    }
+    match(cases) {
+        const results = this.values.map(k => [k, cases[k]()]);
+        if (results.every(([, r]) => r instanceof Cond))
+            return any(...results.map(([k, r]) => all(this.is(k), r)));
+        if (results.some(([, r]) => r instanceof Cond))
+            throw new Error('every case of a match is a condition, or every case is a term');
+        // The last case is what's left: the kind's assumption says the index is below the number of values.
+        return results.slice(0, -1).reduceRight((acc, [k, r]) => when(this.is(k), r, acc), typeof results.at(-1)[1] === 'number' ? lit(results.at(-1)[1]) : results.at(-1)[1]);
+    }
+}
+class OneOfKind extends Kind {
+    values;
+    constructor(values) {
+        super();
+        this.values = values;
+        if (values.length === 0 || new Set(values).size !== values.length)
+            throw new Error('oneOf takes distinct values');
+    }
+    vars(name) { return [name]; }
+    assume(name) { return [v(name).lt(this.values.length)]; }
+    value(name, prefix = '') { return new Choice(v(prefix + name), this.values); }
+    encode(name, raw) {
+        const i = this.values.indexOf(raw);
+        if (i < 0)
+            throw new RangeError(`${name} is one of ${this.values.join(', ')}, not ${String(raw)}`);
+        return { [name]: i };
+    }
+    random(name, rand) { return { [name]: rand(this.values.length) }; }
+}
+export const oneOf = (...values) => new OneOfKind(values);
+// A value that may be missing, encoded as a presence bit and the value. The value can only be read in `some`, so no
+// law or step can read a missing value; the encoding leaves it unconstrained when missing, so nothing proven depends
+// on it.
+export class Maybe {
+    present;
+    inner;
+    constructor(present, inner) {
+        this.present = present;
+        this.inner = inner;
+    }
+    get isSome() { return this.present.eq(1); }
+    get isNone() { return this.present.eq(0); }
+    match(cases) {
+        const none = cases.none(), some = cases.some(this.inner);
+        if (none instanceof Cond && some instanceof Cond)
+            return choose(this.isSome, some, none);
+        if (none instanceof Cond || some instanceof Cond)
+            throw new Error('both cases of a match are conditions, or both are terms');
+        return when(this.isSome, some, none);
+    }
+}
+class MaybeKind extends Kind {
+    of;
+    constructor(of) {
+        super();
+        this.of = of;
+    }
+    has(name) { return `${name}$some`; }
+    vars(name) { return [this.has(name), ...this.of.vars(name)]; }
+    assume(name) { return [v(this.has(name)).atMost(1), ...this.of.assume(name)]; }
+    value(name, prefix = '') { return new Maybe(v(prefix + this.has(name)), this.of.value(name, prefix)); }
+    encode(name, raw) {
+        if (raw === null || raw === undefined)
+            return { [this.has(name)]: 0, ...Object.fromEntries(this.of.vars(name).map(n => [n, 0])) };
+        return { [this.has(name)]: 1, ...this.of.encode(name, raw) };
+    }
+    random(name, rand, bound) {
+        return rand(4) === 0 ? { [this.has(name)]: 0, ...Object.fromEntries(this.of.vars(name).map(n => [n, rand(bound + 1)])) } : { [this.has(name)]: 1, ...this.of.random(name, rand, bound) };
+    }
+}
+export const maybe = (of) => new MaybeKind(of);
+// A map from naturals to naturals, every cell starting at `init`. One write per map per step.
+export class MapRef {
+    name;
+    init;
+    constructor(name, init) {
+        this.name = name;
+        this.init = init;
+    }
+    at(key) { return new Term({ op: 'get', map: this.name, key: termOf(key) }); }
+    set(key, value) { return { map: this.name, key: termOf(key), value: termOf(value) }; }
+    // key's cell plus `by` where `c` holds (the counter every cap keeps).
+    bump(key, c = yes, by = 1) { return this.set(key, when(c, this.at(key).plus(by), this.at(key))); }
+}
+// A law about every key of a map: proven at a fresh key, assumed at the keys a step reads.
+export const forall = (f) => ({ forall: f });
+// For histories: `holds` (a <= b, homogeneous over sums and queries) wherever `when` (params and plain inputs) holds.
+export const relation = (holds, whenever = yes) => ({ when: whenever, holds });
+let keyCounter = 0;
+// A k-step law's later requests are built over marked names (j:name, which no rule can declare: ':' is reserved); the
+// kernel reads them as name@j.
+const markedName = (name) => { const m = /^(\d+):(.*)$/.exec(name); return m ? `${m[2]}@${m[1]}` : name; };
+const markedE = (e) => {
+    switch (e.op) {
+        case 'var': return { op: 'var', name: markedName(e.name) };
+        case 'const': return e;
+        case 'mul': return { ...e, a: markedE(e.a) };
+        case 'if': return { op: 'if', c: marked(e.c), then: markedE(e.then), else: markedE(e.else) };
+        case 'get': return { op: 'get', map: e.map, key: markedE(e.key) };
+        case 'add':
+        case 'sub':
+        case 'min':
+        case 'max':
+        case 'prod': return { ...e, a: markedE(e.a), b: markedE(e.b) };
+    }
+};
+const marked = (c) => c.op === 'flag' ? c : c.op === 'not' ? { op: 'not', x: marked(c.x) } : c.op === 'and' || c.op === 'or' ? { op: c.op, xs: c.xs.map(marked) } : { ...c, a: markedE(c.a), b: markedE(c.b) };
+// P params, I inputs, S state, M maps, F flags, R a history's record, Su its sums, Q its queries: each a record of the
+// values the builders hand out, grown by each call.
+export class Rule {
+    spec;
+    constructor(spec) {
+        this.spec = spec;
+    }
+    with(more) { return new Rule({ ...this.spec, ...more }); }
+    get name() { return this.spec.name; }
+    params(kinds) { return this.with({ params: [...this.spec.params, ...Object.entries(kinds)] }); }
+    inputs(kinds) { return this.with({ inputs: [...this.spec.inputs, ...Object.entries(kinds)] }); }
+    // Each variable starts at a natural or at a term over the params.
+    state(init) {
+        return this.with({ state: [...this.spec.state, ...Object.entries(init)] });
+    }
+    maps(init) { return this.with({ maps: [...this.spec.maps, ...Object.entries(init)] }); }
+    // Named conditions of the step, decided once per step before it; each call's flags may read the earlier calls'. A flag
+    // named again replaces the earlier definition in place (what a variant needs: one call, the step unchanged); the new
+    // definition may read only the flags defined before the original's place, as the kernel checks.
+    flags(f) {
+        return this.with({ flags: [...this.spec.flags, f] });
+    }
+    // The step (replaces an earlier one, so a variant is one call away): its updates read the state before it.
+    step(f) {
+        return this.with({ step: f });
+    }
+    // A precondition on the params: the laws are claimed only for params that meet it.
+    pre(f) { return this.with({ pre: [...this.spec.pre, f] }); }
+    // What every request satisfies (with the input kinds' own assumptions): it holds at each step, not at the start.
+    assume(f) { return this.with({ assume: [...this.spec.assume, f] }); }
+    // A history: the requests the step keeps, each recorded with these inputs.
+    log(...record) { return this.with({ record }); }
+    // State equal to the sum over the history of a term of the record and the params.
+    sums(sums) {
+        return this.with({ sums: [...this.spec.sums, ...Object.entries(sums)] });
+    }
+    // An input the runtime computes: the sum over the history before the request of a term of the record, the params and
+    // the request's other inputs.
+    queries(queries) {
+        return this.with({ queries: [...this.spec.queries, ...Object.entries(queries)] });
+    }
+    keep(f) { return this.with({ keep: f }); }
+    relations(f) { return this.with({ relations: f }); }
+    // Requests come in nondecreasing `order`; a record whose order plus `after` is at most the request's is dropped
+    // (the kernel proves it adds nothing to any query).
+    prune(order, after) { return this.with({ prune: { order, after: after } }); }
+    // A law about the params, the state, the maps and the sums (not a request): `forall` for every key of a map.
+    law(name, f) {
+        const out = f(this.env({ flags: false, inputs: false, queries: false }));
+        if (out instanceof Cond)
+            return { name, holds: out.c };
+        const key = `key$${++keyCounter}`;
+        return { name, forall: key, holds: out.forall(v(key)).c };
+    }
+    // A law about one step, for every request the rule allows: `then(before, after)` relates what the step reads (params,
+    // the request, state, maps, flags, sums, queries) to the state, maps and sums after it. `when` narrows the requests.
+    //   counter.stepLaw('never goes back', ({used}, after) => used.atMost(after.used))
+    stepLaw(name, then, when) {
+        const env = this.env();
+        const after = {};
+        for (const [n] of this.spec.state)
+            after[n] = v(`${n}'`);
+        for (const [n] of this.spec.sums)
+            after[n] = v(`${n}'`);
+        for (const [n, init] of this.spec.maps)
+            after[n] = new MapRef(`${n}'`, init);
+        const out = then(env, after), w = when ? { when: when(env).c } : {};
+        if (out instanceof Cond)
+            return { name, then: out.c, ...w };
+        const key = `key$${++keyCounter}`;
+        return { name, forall: key, then: out.forall(v(key)).c, ...w };
+    }
+    // A law about k steps in a row (k from 2 to 16): `then(first, last, requests)` relates what the first step reads to the
+    // state, maps and sums after the last, with each step's request and queries (requests[0] is the first's); `when(before,
+    // j)` narrows the j-th step's request (j from 0), read at the state that step starts from.
+    //   meter.stepsLaw('two requests spend at most 2m', 2, ({spent, m}, after) => after.spent.atMost(spent.plus(m).plus(m)))
+    stepsLaw(name, k, then, when) {
+        const env = this.env();
+        const after = {};
+        for (const [n] of this.spec.state)
+            after[n] = v(`${n}'`);
+        for (const [n] of this.spec.sums)
+            after[n] = v(`${n}'`);
+        for (const [n, init] of this.spec.maps)
+            after[n] = new MapRef(`${n}'`, init);
+        // The j-th request's values over marked names, renamed to the kernel's input@j once built.
+        const mark = (j) => `${j}:`;
+        const requests = Array.from({ length: k }, (_, j) => {
+            if (j === 0)
+                return Object.fromEntries([...this.spec.inputs.map(([n]) => n), ...this.spec.queries.map(([n]) => n)].map(n => [n, env[n]]));
+            return Object.fromEntries([...this.spec.inputs.map(([n, kind]) => [n, kind.value(n, mark(j + 1))]), ...this.spec.queries.map(([n]) => [n, v(`${mark(j + 1)}${n}`)])]);
+        });
+        const out = then(env, after, requests);
+        const whens = when ? Array.from({ length: k }, (_, j) => when(env, j)) : [];
+        while (whens.length && whens.at(-1) === undefined)
+            whens.pop();
+        const w = whens.length ? { when: whens.map(c => (c ?? lit(0).atMost(0)).c) } : {};
+        if (out instanceof Cond)
+            return { name, steps: k, then: marked(out.c), ...w };
+        const key = `key$${++keyCounter}`;
+        return { name, steps: k, forall: key, then: marked(out.forall(v(key)).c), ...w };
+    }
+    // A decision: whenever the params and the request meet `given`, `then` holds. Decisions don't read the state.
+    decide(name, given, then) {
+        const env = this.env({ flags: false, state: false, queries: false });
+        const g = given(env), hyps = [...this.kindAssumptions(), ...this.spec.pre.map(f => f(env).c), ...this.spec.assume.map(f => f(env).c), ...(Array.isArray(g) ? g : [g]).map(c => c.c)];
+        const t = then(env).c;
+        return { name, rule: this, given: hyps, then: t, goal: { name, hyps: [...hyps, { op: 'not', x: t }] } };
+    }
+    // --- what it compiles to ------------------------------------------------------------------------------------------
+    kindAssumptions(which = 'both') {
+        const ps = which === 'inputs' ? [] : this.spec.params.flatMap(([n, k]) => k.assume(n));
+        const is = which === 'params' ? [] : this.spec.inputs.flatMap(([n, k]) => k.assume(n));
+        return [...ps, ...is].map(c => c.c);
+    }
+    // The values handed to the builders' callbacks.
+    env(parts = {}) {
+        const out = {};
+        for (const [n, k] of this.spec.params)
+            out[n] = k.value(n);
+        if (parts.inputs !== false)
+            for (const [n, k] of this.spec.inputs)
+                out[n] = k.value(n);
+        if (parts.state !== false) {
+            for (const [n] of this.spec.state)
+                out[n] = v(n);
+            for (const [n, init] of this.spec.maps)
+                out[n] = new MapRef(n, init);
+            for (const [n] of this.spec.sums)
+                out[n] = v(n);
+        }
+        if (parts.queries !== false)
+            for (const [n] of this.spec.queries)
+                out[n] = v(n);
+        if (parts.flags !== false)
+            for (const f of this.spec.flags)
+                for (const n of Object.keys(f(out)))
+                    out[n] = new Cond({ op: 'flag', name: n });
+        return out;
+    }
+    get machine() {
+        const s = this.spec;
+        const params = s.params.flatMap(([n, k]) => k.vars(n)), queries = s.queries.map(([n]) => n);
+        const inputs = [...s.inputs.flatMap(([n, k]) => k.vars(n)), ...queries];
+        const pEnv = this.env({ inputs: false, state: false, flags: false, queries: false });
+        const env = this.env({ flags: false });
+        const flags = {};
+        for (const f of s.flags)
+            for (const [n, c] of Object.entries(f(env))) {
+                flags[n] = c.c;
+                env[n] = new Cond({ op: 'flag', name: n });
+            } // a name again: replaced in place
+        const updates = s.step?.(env) ?? {};
+        const state = {}, maps = {};
+        for (const [n, u] of Object.entries(updates)) {
+            if (u === undefined)
+                continue;
+            if (typeof u === 'object' && 'map' in u) {
+                if (u.map !== n)
+                    throw new Error(`${s.name}: the step writes map ${u.map} under the name ${n}`);
+                maps[n] = { key: u.key, value: u.value };
+            }
+            else
+                state[n] = termOf(u);
+        }
+        const pre = [...this.kindAssumptions('params'), ...s.pre.map(f => f(pEnv).c)];
+        const assume = [...this.kindAssumptions('inputs'), ...s.assume.map(f => f(env).c)];
+        const m = {
+            name: s.name, params, inputs,
+            state: Object.fromEntries(s.state.map(([n, init]) => [n, typeof init === 'number' ? termOf(init) : termOf(init(pEnv))])),
+            ...(s.maps.length ? { maps: Object.fromEntries(s.maps) } : {}),
+            step: { ...(Object.keys(flags).length ? { flags } : {}), ...(Object.keys(state).length ? { state } : {}), ...(Object.keys(maps).length ? { maps } : {}) },
+            ...(pre.length ? { pre: pre.length === 1 ? pre[0] : { op: 'and', xs: pre } } : {}),
+            ...(assume.length ? { assume: assume.length === 1 ? assume[0] : { op: 'and', xs: assume } } : {}),
+        };
+        if (s.record) {
+            const kinds = new Map(s.inputs);
+            const record = Object.fromEntries(s.record.map(n => [n, kinds.get(n).value(n, 'r.')]));
+            const plain = this.env({ state: false, flags: false, queries: false });
+            const rv = Object.fromEntries(Object.entries(env).filter(([n]) => queries.includes(n) || s.sums.some(([sn]) => sn === n) || n in plain));
+            const pruneOrder = s.prune ? kinds.get(s.prune.order).vars(s.prune.order) : undefined;
+            if (pruneOrder && pruneOrder.length !== 1)
+                throw new Error(`${s.name}: a history is pruned by a single-variable input`);
+            m.history = {
+                keep: (s.keep?.(env) ?? yes).c,
+                record: s.record.flatMap(n => kinds.get(n).vars(n)),
+                sums: Object.fromEntries(s.sums.map(([n, f]) => [n, termOf(f(record, pEnv))])),
+                queries: Object.fromEntries(s.queries.map(([n, f]) => [n, termOf(f(record, plain))])),
+                ...(s.relations ? { relations: s.relations(rv).map(r => ({ when: r.when.c, holds: r.holds.c })) } : {}),
+                ...(s.prune ? { prune: { order: pruneOrder[0], after: termOf(s.prune.after(pEnv)) } } : {}),
+            };
+        }
+        return m;
+    }
+    // --- running it -----------------------------------------------------------------------------------------------------
+    // Runtime values (numbers, booleans, choice names, null for a missing value) to the variables the machine reads.
+    encodeParams(values) { return encode(this.spec.params, values); }
+    encodeInput(values) { return encode(this.spec.inputs, values); }
+    // Random params and inputs that meet their kinds (not the user's `pre` or `assume`, which a caller checks).
+    randomParams(rand, bound) { return Object.assign({}, ...this.spec.params.map(([n, k]) => k.random(n, rand, bound))); }
+    randomInput(rand, bound) { return Object.assign({}, ...this.spec.inputs.map(([n, k]) => k.random(n, rand, bound))); }
+    // The prune order's variable, if the history is pruned (a runtime must send it nondecreasing).
+    get orderedBy() { return this.spec.prune ? new Map(this.spec.inputs).get(this.spec.prune.order).vars(this.spec.prune.order)[0] : undefined; }
+    interpreter() { return interpret(this.machine); }
+    compiled() {
+        return loadJs(this.machine);
+    }
+}
+const encode = (kinds, values) => Object.assign({}, ...kinds.map(([n, k]) => k.encode(n, values[n])));
+export const rule = (name) => new Rule({ name, params: [], inputs: [], state: [], maps: [], flags: [], pre: [], assume: [], sums: [], queries: [] });
+// A loop runs `body` while `while` holds, each turn with fresh inputs; it halts if a rank over the state and params
+// (or a tuple of them, compared in order) drops on every turn.
+export class LoopRule {
+    spec;
+    constructor(spec) {
+        this.spec = spec;
+    }
+    with(more) { return new LoopRule({ ...this.spec, ...more }); }
+    params(kinds) { return this.with({ params: [...this.spec.params, ...Object.entries(kinds)] }); }
+    inputs(kinds) { return this.with({ inputs: [...this.spec.inputs, ...Object.entries(kinds)] }); }
+    state(init) { return this.with({ state: [...this.spec.state, ...Object.entries(init)] }); }
+    while(f) { return this.with({ while: f }); }
+    body(f) { return this.with({ body: f }); }
+    pre(f) { return this.with({ pre: [...this.spec.pre, f] }); }
+    assume(f) { return this.with({ assume: [...this.spec.assume, f] }); }
+    rank(f) { return this.with({ rank: f }); }
+    law(name, f) { return { name, holds: f(this.env(false)).c }; }
+    env(inputs = true) {
+        const out = {};
+        for (const [n, k] of this.spec.params)
+            out[n] = k.value(n);
+        if (inputs)
+            for (const [n, k] of this.spec.inputs)
+                out[n] = k.value(n);
+        for (const [n] of this.spec.state)
+            out[n] = v(n);
+        return out;
+    }
+    get loop() {
+        const s = this.spec, env = this.env(), pEnv = Object.fromEntries(s.params.map(([n, k]) => [n, k.value(n)]));
+        if (!s.while || !s.body)
+            throw new Error(`${s.name}: a loop needs while and body`);
+        const pre = [...s.params.flatMap(([n, k]) => k.assume(n)).map(c => c.c), ...s.pre.map(f => f(pEnv).c)];
+        const assume = [...s.inputs.flatMap(([n, k]) => k.assume(n)).map(c => c.c), ...s.assume.map(f => f(env).c)];
+        return {
+            name: s.name, params: s.params.flatMap(([n, k]) => k.vars(n)), inputs: s.inputs.flatMap(([n, k]) => k.vars(n)),
+            state: Object.fromEntries(s.state.map(([n, init]) => [n, typeof init === 'number' ? termOf(init) : termOf(init(pEnv))])),
+            while: s.while(env).c,
+            body: Object.fromEntries(Object.entries(s.body(env)).filter(([, t]) => t !== undefined).map(([n, t]) => [n, termOf(t)])),
+            ...(pre.length ? { pre: pre.length === 1 ? pre[0] : { op: 'and', xs: pre } } : {}),
+            ...(assume.length ? { assume: assume.length === 1 ? assume[0] : { op: 'and', xs: assume } } : {}),
+        };
+    }
+    get rankTerms() {
+        if (!this.spec.rank)
+            throw new Error(`${this.spec.name}: no rank`);
+        const r = this.spec.rank(this.env(false));
+        return (Array.isArray(r) ? r : [r]).map(termOf);
+    }
+    randomParams(rand, bound) { return Object.assign({}, ...this.spec.params.map(([n, k]) => k.random(n, rand, bound))); }
+    randomInput(rand, bound) { return Object.assign({}, ...this.spec.inputs.map(([n, k]) => k.random(n, rand, bound))); }
+}
+export const loop = (name) => new LoopRule({ name, params: [], inputs: [], state: [], pre: [], assume: [] });
+const goalsVerdict = (goals) => {
+    const trees = {};
+    for (const g of goals) {
+        const out = grow(g);
+        if (!('tree' in out))
+            return { proven: false, checked: false, goal: g.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}) };
+        trees[g.name] = out.tree;
+    }
+    return { proven: true, checked: goals.every(g => check(g, trees[g.name])), trees };
+};
+export function proveRule(r, laws) {
+    const out = proveLaws(r.machine, laws);
+    return { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}) } : {}) };
+}
+export function proveSteps(r, laws, stepLaws) {
+    const out = proveStepLaws(r.machine, laws, stepLaws);
+    return { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}) } : {}) };
+}
+export const proveDecision = (d) => goalsVerdict([d.goal]);
+export const proveLoop = (l, laws) => goalsVerdict(loopObligations(l.loop, laws, l.rankTerms));

package/dist/core/machine.d.ts

@@ -0,0 +1,145 @@
+import { type Constraint, type Verdict } from './solver.js';
+export type E = {
+    op: 'var';
+    name: string;
+} | {
+    op: 'const';
+    value: number;
+} | {
+    op: 'add' | 'sub' | 'min' | 'max';
+    a: E;
+    b: E;
+} | {
+    op: 'mul';
+    k: number;
+    a: E;
+} | {
+    op: 'prod';
+    a: E;
+    b: E;
+} | {
+    op: 'if';
+    c: C;
+    then: E;
+    else: E;
+} | {
+    op: 'get';
+    map: string;
+    key: E;
+};
+export type C = {
+    op: '<' | '<=' | '=';
+    a: E;
+    b: E;
+} | {
+    op: 'and';
+    xs: C[];
+} | {
+    op: 'or';
+    xs: C[];
+} | {
+    op: 'not';
+    x: C;
+} | {
+    op: 'flag';
+    name: string;
+};
+export type Machine = {
+    name: string;
+    params: string[];
+    inputs: string[];
+    state: Record<string, E>;
+    maps?: Record<string, number>;
+    step: {
+        flags?: Record<string, C>;
+        state?: Record<string, E>;
+        maps?: Record<string, {
+            key: E;
+            value: E;
+        }>;
+    };
+    pre?: C;
+    assume?: C;
+    history?: History;
+};
+export type History = {
+    keep: C;
+    record: string[];
+    sums: Record<string, E>;
+    queries: Record<string, E>;
+    relations?: {
+        when: C;
+        holds: C;
+    }[];
+    prune?: {
+        order: string;
+        after: E;
+    };
+};
+export type Law = {
+    name: string;
+    holds: C;
+    forall?: string;
+};
+export { unreachable } from '../kernel/kernel.js';
+export declare const x: (name: string) => E;
+export declare const n: (value: number) => E;
+export declare const plus: (a: E, b: E) => E;
+export declare const minus: (a: E, b: E) => E;
+export declare const times: (factor: number, a: E) => E;
+export declare const min: (a: E, b: E) => E;
+export declare const max: (a: E, b: E) => E;
+export declare const prod: (a: E, b: E) => E;
+export declare const ite: (c: C, then: E, otherwise: E) => E;
+export declare const get: (map: string, key: E) => E;
+export declare const less: (a: E, b: E) => C;
+export declare const atMost: (a: E, b: E) => C;
+export declare const same: (a: E, b: E) => C;
+export declare const all: (...xs: C[]) => C;
+export declare const any: (...xs: C[]) => C;
+export declare const not: (c: C) => C;
+export declare const bit: (name: string) => C;
+export type State = {
+    scalars: Record<string, number>;
+    maps: Record<string, Map<number, number>>;
+    history?: Env[];
+    last?: number;
+};
+type Env = Record<string, number>;
+export declare const naturalIn: (v: unknown, what: string) => number;
+export declare function evalE(e: E, env: Env, st: State, m: Machine): number;
+export declare function evalC(c: C, env: Env, st: State, m: Machine): boolean;
+export declare function interpret(m: Machine): {
+    init: (params: Env) => State;
+    queries: (params: Env, st: State, input: Env) => Env;
+    step: (params: Env, st: State, input: Env) => State;
+};
+export declare function compileJs(m: Machine): string;
+export declare function compileFunction<F>(params: string[], body: string): F;
+export type Compiled = {
+    init: (params: object) => State & {
+        head?: number;
+    };
+    fork: (st: State) => State;
+    step: (params: object, st: State, input: object) => State & {
+        head?: number;
+    };
+};
+export declare const loadJs: (m: Machine) => Compiled;
+export type Obligation = {
+    phase: 'start' | 'step';
+    law: string;
+    constraints: Constraint[];
+    verdict: Verdict;
+};
+export type Proof = {
+    law: Law;
+    proven: boolean;
+    obligations: Obligation[];
+};
+export declare function prove(m: Machine, goal: Law, invariants?: Law[]): Proof;
+export declare function search(m: Machine, law: Law, depth?: number, bound?: number): {
+    params: Env;
+    trace: Env[];
+} | undefined;
+export declare function conditionCases(c: C, truth: boolean): Constraint[][];