gdp-wired 0.19.0 → 0.21.0

package/dist/core/dsl.js

@@ -15,14 +15,15 @@
 //
 // 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 { carriedView, compileFunction, evalC, evalE, interpret, loadJs, numbersOf, pairedArgs } from "./machine.js";
+import { carriedView, compileFunction, divName, divisor, divisorsIn, evalC, evalE, interpret, isArithmetic, loadJs, modName, numbersOf, pairedArgs, withArithmetic } from "./machine.js";
 import { allowed, keysOf, requestEnv, watch } from "./watch.js";
+import { someHolds, substVars } from "./exists.js";
 import { check, foldObligations, loopObligations } from "../kernel/kernel.js";
 import { factsFor, grow, proveLaws, proveLiveness, proveStepLaws, usualProof, withDeadline } from "../kernel/prove.js";
-import { certCyclic, certOn, crossCyclic, cyclicOn, cycLog, foldNodes, proveCyclic, quietly, recurNodes, translatedProof } from "./cyclic.js";
+import { certCyclic, certOn, crossCyclic, cyclicOn, foldNodes, proveCyclic, quietly, recurNodes, translatedProof, uncovered } from "./cyclic.js";
 import { discover } from "./discover.js";
 import { inferLaws } from "./infer.js";
-import { cycleLemmas, findRank } from "./cycles.js";
+import { cycleLemmas, findLeadsTo, findRank } from "./cycles.js";
 // --- terms and conditions -------------------------------------------------------------------------------------------
 const naturalConst = (v) => {
     if (!Number.isSafeInteger(v) || v < 0)
@@ -53,6 +54,11 @@ export class Term {
     minus(b) { return new Term({ op: 'sub', a: this.e, b: termOf(b) }, both(this.val, valOf(b), (x, y) => Math.max(0, x - y))); }
     times(k) { return new Term({ op: 'mul', k: naturalConst(k), a: this.e }, both(this.val, k, (x, y) => x * y)); }
     mul(b) { return new Term({ op: 'prod', a: this.e, b: termOf(b) }, both(this.val, valOf(b), (x, y) => x * y)); }
+    // x div k and x mod k, rounded down, for a constant k >= 1: the rule's functions div$k and mod$k at x, which the
+    // kernel knows by x = k·(x div k) + x mod k and x mod k < k (machine.ts's arithmetic). Division by a term that isn't a
+    // constant has no such fact in linear arithmetic (x = y·q + r is a product of two unknowns), so it isn't offered.
+    modBy(k) { divisor(k, 'modBy'); return new Term({ op: 'get', map: modName(k), key: this.e }, this.val === undefined ? undefined : this.val % k); }
+    divBy(k) { divisor(k, 'divBy'); return new Term({ op: 'get', map: divName(k), key: this.e }, this.val === undefined ? undefined : Math.floor(this.val / k)); }
     lt(b) { return new Cond({ op: '<', a: this.e, b: termOf(b) }, both(this.val, valOf(b), (x, y) => x < y)); }
     atMost(b) { return new Cond({ op: '<=', a: this.e, b: termOf(b) }, both(this.val, valOf(b), (x, y) => x <= y)); }
     gt(b) { return new Cond({ op: '<', a: termOf(b), b: this.e }, both(this.val, valOf(b), (x, y) => x > y)); }
@@ -67,21 +73,26 @@ const known = (xs) => (xs.every(x => x !== undefined) ? xs : undefined);
 export class Cond {
     c;
     ok;
-    constructor(c, ok) {
+    ex;
+    // `ex`: the existentials (exists) inside, each with whether it reads as "there exists" where it sits (under no not, or
+    // an even number of them): a law, the assumption or a precondition pulls each such one out as ∃ before the whole.
+    constructor(c, ok, ex) {
         this.c = c;
         this.ok = ok;
+        this.ex = ex;
     }
     and(...xs) { return all(this, ...xs); }
     or(...xs) { return any(this, ...xs); }
-    not() { return new Cond({ op: 'not', x: this.c }, this.ok === undefined ? undefined : !this.ok); }
+    not() { return new Cond({ op: 'not', x: this.c }, this.ok === undefined ? undefined : !this.ok, this.ex?.map(b => ({ ...b, pos: !b.pos }))); }
     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), v);
 export const yes = new Cond({ op: '<=', a: { op: 'const', value: 0 }, b: { op: 'const', value: 0 } }, true);
 export const no = new Cond({ op: '<', a: { op: 'const', value: 0 }, b: { op: 'const', value: 0 } }, false);
-export const all = (...cs) => (cs.length === 0 ? yes : cs.length === 1 ? cs[0] : new Cond({ op: 'and', xs: cs.map(c => c.c) }, known(cs.map(c => c.ok))?.every(x => x)));
-export const any = (...cs) => (cs.length === 0 ? no : cs.length === 1 ? cs[0] : new Cond({ op: 'or', xs: cs.map(c => c.c) }, known(cs.map(c => c.ok))?.some(x => x)));
+const exOf = (cs) => (cs.some(c => c.ex?.length) ? cs.flatMap(c => c.ex ?? []) : undefined);
+export const all = (...cs) => (cs.length === 0 ? yes : cs.length === 1 ? cs[0] : new Cond({ op: 'and', xs: cs.map(c => c.c) }, known(cs.map(c => c.ok))?.every(x => x), exOf(cs)));
+export const any = (...cs) => (cs.length === 0 ? no : cs.length === 1 ? cs[0] : new Cond({ op: 'or', xs: cs.map(c => c.c) }, known(cs.map(c => c.ok))?.some(x => x), exOf(cs)));
 export const not = (c) => c.not();
 export const min = (a, b) => new Term({ op: 'min', a: termOf(a), b: termOf(b) }, both(valOf(a), valOf(b), Math.min));
 export const max = (a, b) => new Term({ op: 'max', a: termOf(a), b: termOf(b) }, both(valOf(a), valOf(b), Math.max));
@@ -244,6 +255,11 @@ export class Int {
     min(b) { return when(this.atMost(b), this, b); }
     max(b) { return when(this.atLeast(b), this, b); }
     get isNegative() { return this.neg.gt(this.pos); }
+    // x mod k and x div k for a constant k >= 1, as SMT-LIB and Lean's Int read them for k > 0: x = k·(x div k) + x mod k
+    // with 0 <= x mod k < k (so -7 div 2 is -4 and -7 mod 2 is 1). Over the naturals: pos + (k − 1)·neg is x + k·neg,
+    // the same remainder, and its quotient is x div k + neg, so both are the natural division of that one natural.
+    modBy(k) { divisor(k, 'modBy'); return add(this.pos, this.neg.times(k - 1)).modBy(k); }
+    divBy(k) { divisor(k, 'divBy'); return new Int(add(this.pos, this.neg.times(k - 1)).divBy(k), this.neg); }
     // |value|, and the value where it is not negative (0 below).
     get abs() { return this.pos.minus(this.neg).plus(this.neg.minus(this.pos)); }
     get clamped() { return this.pos.minus(this.neg); }
@@ -808,6 +824,32 @@ export const someKey = (f, witness) => {
     const none = everyOk(scope?.keys, k => f(keyTerm(k)).not().ok);
     return new Cond({ op: 'not', x: { op: 'all', key, c: f(v(key)).not().c, ...(witness === undefined ? {} : { witness: termOf(witness) }) } }, none === undefined ? undefined : !none);
 };
+export function exists(a, b, c) {
+    const [kind, f, w] = (a instanceof Kind ? [a, b, c] : [nat, a, b]);
+    const name = `some$${++boundCounter}`, value = kind.value(name), body = all(...kind.assume(name), f(value));
+    const store = (x) => Object.fromEntries(Object.entries(kind.store(name, x)).map(([n, t]) => [n, termOf(t)]));
+    const ghost = typeof w === 'object' && w !== null && 'step' in w && 'start' in w && typeof w.step === 'function';
+    const given = w === undefined ? {} : ghost
+        ? { start: store(w.start), step: (env) => store(w.step(value, env)) }
+        : { terms: store(w) };
+    return new Cond(body.c, undefined, [...(body.ex ?? []), { vars: kind.vars(name), body: body.c, pos: true, ...given }]);
+}
+// A condition's existentials pulled out before it (each reading as "there exists"), their naturals renamed `${prefix}0`,
+// `${prefix}1`, ... (an integer's second part keeping $neg), so a machine built again names them alike.
+function pulledOut(cs, what, prefix) {
+    const bs = cs.flatMap(c => c.ex ?? []);
+    if (bs.some(b => !b.pos))
+        throw new Error(`${what}: exists(...) under a not (or on the left of implies) says "for every value"; state it as a law about every value of a param instead`);
+    const ren = {};
+    if (prefix !== undefined)
+        bs.forEach((b, i) => b.vars.forEach(n => { ren[n] = { op: 'var', name: n.endsWith('$neg') ? `${prefix}${i}$neg` : `${prefix}${i}` }; }));
+    const r = (c) => (prefix === undefined ? c : substVars(c, ren));
+    const vars = bs.flatMap(b => b.vars.map(n => (prefix === undefined ? n : ren[n].name)));
+    const out = cs.map(c => r(c.c)), stray = out.flatMap(c => namesIn(c)).filter(n => n.startsWith('some$') && !vars.includes(n) && !/^some\$[ap]\d/.test(n));
+    if (stray.length)
+        throw new Error(`${what}: ${stray[0]} is bound by an exists(...) whose condition was taken apart; keep it whole (and, or, not, implies)`);
+    return { cs: out, vars, bodies: bs.map(b => ({ vars: b.vars.map(n => (prefix === undefined ? n : ren[n].name)), body: r(b.body) })) };
+}
 // A map from naturals to naturals, every cell starting at `init`. One write per map per step.
 export class MapRef {
     name;
@@ -1430,8 +1472,12 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
         lemmaProof = usualProof.last;
         if (cyclicOn())
             crossCyclic('recurrence', name, verdict.proven && verdict.checked, () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0, translatedRecur({ lemmas: lemmaProof }));
-        if (certOn() && verdict.proven && verdict.checked)
-            verdict = { ...verdict, checked: certCyclic('recurrence', name, translatedRecur({ lemmas: lemmaProof }), () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0).checked };
+        // (the usual trees checked already, inside quietly: where no cyclic proof is made they are the certificate)
+        if (certOn() && verdict.proven && verdict.checked) {
+            const c = certCyclic('recurrence', name, translatedRecur({ lemmas: lemmaProof }), () => { const { facts, specs } = recurNodes(recurCase([])); return proveCyclic(facts, specs); }, performance.now() - t0);
+            if (!c.checked)
+                uncovered('recurrence', name, c.why);
+        }
         failed('lemmas', verdict);
         proofs.lemmas = { machine: r.machine, laws };
     }
@@ -1472,8 +1518,11 @@ export const recur = (name, def, lemmas = {}, between = {}) => {
         const t0 = performance.now(), v = quietly(() => proveRule(r, laws, { search: false })), usualMs = performance.now() - t0, betweenProof = usualProof.last;
         if (cyclicOn())
             crossCyclic('recurrence, between', name, v.proven && v.checked, () => { const { facts, specs } = recurNodes(recurCase(pairs)); return proveCyclic(facts, specs); }, usualMs, betweenProof && translatedRecur({ lemmas: lemmaProof, between: betweenProof }));
-        if (certOn() && v.proven && v.checked)
-            v.checked = certCyclic('recurrence, between', name, betweenProof && translatedRecur({ lemmas: lemmaProof, between: betweenProof }), () => { const { facts, specs } = recurNodes(recurCase(pairs)); return proveCyclic(facts, specs); }, usualMs).checked;
+        if (certOn() && v.proven && v.checked) {
+            const c = certCyclic('recurrence, between', name, betweenProof && translatedRecur({ lemmas: lemmaProof, between: betweenProof }), () => { const { facts, specs } = recurNodes(recurCase(pairs)); return proveCyclic(facts, specs); }, usualMs);
+            if (!c.checked)
+                uncovered('recurrence, between', name, c.why);
+        }
         failed('laws between two points', v);
         proofs.between = { machine: r.machine, laws };
         verdict = { proven: true, checked: verdict.checked && v.checked };
@@ -1565,6 +1614,8 @@ const fnValueOf = (d) => {
 };
 let keyCounter = 0;
 const sources = new WeakMap();
+// A rule's existentials in its precondition and assumption (core/exists.ts): what encodeParams and encodeInput find.
+const skolemsOf = new WeakMap();
 const withSource = (x, src) => (sources.set(x, src), x);
 // 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.
@@ -1761,11 +1812,37 @@ export class Rule {
         const key = `key$${++keyCounter}`;
         if (out instanceof Cond) {
             const p = prenex(out.c, `law ${name}`, key);
-            return p ? { name, forall: key, holds: p } : { name, holds: out.c };
+            return this.divides(this.someOf(name, out, p ? { name, forall: key, holds: p } : { name, holds: out.c }));
         }
-        const [k1, more] = keysFor(out), holds = out.forall(v(k1), ...more.map(v)).c;
-        return more.length ? { name, forall: k1, keys: more, holds } : { name, forall: k1, holds: prenex(holds, `law ${name}`, k1) ?? holds };
-    }
+        const [k1, more] = keysFor(out), inner = out.forall(v(k1), ...more.map(v)), holds = inner.c;
+        return this.divides(this.someOf(name, inner, more.length ? { name, forall: k1, keys: more, holds } : { name, forall: k1, holds: prenex(holds, `law ${name}`, k1) ?? holds }));
+    }
+    // A law's existentials (exists), pulled out before it: `some` its naturals, `witness` the ones given (a ghost's step
+    // read with the step's own values).
+    someOf(name, out, law) {
+        if (!out.ex?.length)
+            return law;
+        const { vars } = pulledOut([out], `law ${name}`), bs = out.ex;
+        const terms = Object.assign({}, ...bs.map(b => b.terms ?? {}));
+        const ghost = {};
+        const env = bs.some(b => b.step) ? this.env({}) : {};
+        for (const b of bs)
+            if (b.start && b.step) {
+                const st = b.step(env);
+                for (const n of b.vars)
+                    ghost[n] = { start: b.start[n] ?? { op: 'const', value: 0 }, step: st[n] ?? { op: 'var', name: n } };
+            }
+        const witness = { ...(Object.keys(terms).length ? { terms } : {}), ...(Object.keys(ghost).length ? { ghost } : {}) };
+        return { ...law, some: vars, ...(Object.keys(witness).length ? { witness } : {}) };
+    }
+    // What a law, a step law or a decision divides by, noted so the machine declares it (Spec.arith).
+    divides(x) { if (this.spec.arith)
+        divisorsIn([x], this.spec.arith); return x; }
+    // Divide by these too (inferLaws' candidates): the machine declares div$k and mod$k for each.
+    dividesBy(...ks) { for (const k of ks)
+        (this.spec.arith ??= new Set()).add(divisor(k, 'dividesBy')); return this; }
+    // The same rule dividing by these too, its own divisors left as they are.
+    withDivisors(...ks) { return this.with({ arith: new Set([...(this.spec.arith ?? []), ...ks.map(k => divisor(k, 'withDivisors'))]) }); }
     // What the kinds keep true of the state and of the maps and lists of a kind (Kind.invariant: a flag 0 or 1, a choice or
     // a case in range, a presence bit 0 or 1), as laws: proveRule, proveSteps and proveLeadsTo prove them beside the laws
     // they are given, so a law may lean on "the hold is idle, holding or released" without stating it; give them to
@@ -1798,10 +1875,10 @@ export class Rule {
         const key = `key$${++keyCounter}`, src = { step: { then: then, ...(when ? { when: when } : {}) } };
         if (out instanceof Cond) {
             const p = prenex(out.c, `step law ${name}`, key);
-            return withSource(p ? { name, forall: key, then: p, ...w } : { name, then: out.c, ...w }, src);
+            return withSource(this.divides(p ? { name, forall: key, then: p, ...w } : { name, then: out.c, ...w }), src);
         }
         const [k1, more] = keysFor(out), c = out.forall(v(k1), ...more.map(v)).c;
-        return withSource(more.length ? { name, forall: k1, keys: more, then: c, ...w } : { name, forall: k1, then: prenex(c, `step law ${name}`, k1) ?? c, ...w }, src);
+        return withSource(this.divides(more.length ? { name, forall: k1, keys: more, then: c, ...w } : { name, forall: k1, then: prenex(c, `step law ${name}`, k1) ?? c, ...w }), src);
     }
     // A law about k steps in a row (k from 2 to 64): `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,
@@ -1825,10 +1902,10 @@ export class Rule {
         const key = `key$${++keyCounter}`;
         if (out instanceof Cond) {
             const p = prenex(out.c, `step law ${name}`, key);
-            return p ? { name, steps: k, forall: key, then: marked(p), ...w } : { name, steps: k, then: marked(out.c), ...w };
+            return this.divides(p ? { name, steps: k, forall: key, then: marked(p), ...w } : { name, steps: k, then: marked(out.c), ...w });
         }
         const [k1, more] = keysFor(out), c = out.forall(v(k1), ...more.map(v)).c;
-        return more.length ? { name, steps: k, forall: k1, keys: more, then: marked(c), ...w } : { name, steps: k, forall: k1, then: marked(prenex(c, `step law ${name}`, k1) ?? c), ...w };
+        return this.divides(more.length ? { name, steps: k, forall: k1, keys: more, then: marked(c), ...w } : { name, steps: k, forall: k1, then: marked(prenex(c, `step law ${name}`, k1) ?? c), ...w });
     }
     // "Whenever `from` holds, `to` holds later", in every run that takes each helpful request infinitely often: proven by
     // a rank (a natural over the state and params, or several compared in order) that no step raises while `from` holds
@@ -1839,12 +1916,13 @@ export class Rule {
     //     rank: ({t, served}) => t.plus(1).minus(served), helpful: () => ({op: 1})})
     //   batches.leadsTo('every batch is done', {from: () => yes, to: ({waiting, items}) => waiting.eq(0).and(items.eq(0)),
     //     rank: ({waiting, items}) => [waiting, items], helpful: [{when: ({items}) => items.gt(0), request: () => ({op: 1})}, {when: ({items}) => items.eq(0), request: () => ({op: 0})}]})
+    // With no rank, proveLeadsTo finds one from the rule's runs (core/cycles.ts's findLeadsTo).
     leadsTo(name, spec) {
         const env = this.env({ flags: false, inputs: false, queries: false });
         const req = (f) => Object.fromEntries(Object.entries(f(env)).map(([n, t]) => [n, termOf(t)]));
-        const r = spec.rank(env), rank = Array.isArray(r) ? r.map(termOf) : termOf(r);
+        const r = spec.rank ? spec.rank(env) : [], rank = Array.isArray(r) ? r.map(termOf) : termOf(r);
         const base = { name, from: spec.from(env).c, to: spec.to(env).c, rank };
-        return typeof spec.helpful === 'function' ? { ...base, request: req(spec.helpful) } : { ...base, helpful: spec.helpful.map(h => ({ ...(h.when ? { when: h.when(env).c } : {}), request: req(h.request) })) };
+        return this.divides(typeof spec.helpful === 'function' ? { ...base, request: req(spec.helpful) } : { ...base, helpful: spec.helpful.map(h => ({ ...(h.when ? { when: h.when(env).c } : {}), request: req(h.request) })) });
     }
     // A decision: whenever the params and the request meet `given`, `then` holds. Decisions don't read the state; the
     // functions' facts are assumed at the arguments the decision reads them at, and a carried list's equations (each
@@ -1857,8 +1935,8 @@ export class Rule {
         const t = then(env).c;
         const lists = (this.spec.lists2 ?? []).map(([n]) => env[n]);
         const listed = lists.flatMap(l => l.equationsAt(uniqueTerms([l.len, l.len.minus(1), ...keysRead([...hyps, t], l.maps)])).map(c => c.c));
-        const goal = { name, hyps: [...listed, ...hyps, { op: 'not', x: t }] };
-        const facts = this.spec.fns?.length || this.spec.facts?.length ? factsFor(this.machine, goal) : [];
+        const goal = this.divides({ name, hyps: [...listed, ...hyps, { op: 'not', x: t }] });
+        const facts = this.spec.fns?.length || this.spec.facts?.length || this.spec.arith?.size ? factsFor(this.machine, goal) : [];
         const d = { name, rule: this, given: hyps, then: t, goal: { name, hyps: [...facts, ...goal.hyps] } };
         if ([...(Array.isArray(g) ? g : [g]).map(c => c.c), t].some(quantifiedIn)) {
             const conds = (e) => { const own = given(e); return { given$: all(...(Array.isArray(own) ? own : [own])), then$: then(e) }; };
@@ -2053,8 +2131,20 @@ export class Rule {
             else
                 state[n] = hoist.term(termOf(u));
         }
-        const pre = [...this.kindAssumptions('params'), ...s.pre.map(f => f(pEnv).c)];
-        const assume = [...this.kindAssumptions('inputs'), ...(s.lists2 ?? []).flatMap(([n]) => env[n].equations().map(c => hoist.cond(c.c))), ...s.assume.map(f => hoist.cond(f(env).c))];
+        // An existential in a precondition or the assumption: a value the params or the request bring (a param or an input
+        // the runtimes find, encodeParams and encodeInput), fresh for each existential and, for a request, each step.
+        const pre0 = pulledOut(s.pre.map(f => f(pEnv)), `${s.name}: a precondition`, 'some$p'), as0 = pulledOut(s.assume.map(f => f(env)), `${s.name}: the assumption`, 'some$a');
+        const known = new Set([...params, ...inputs]);
+        for (const b of as0.bodies) {
+            const out = namesIn(b.body).filter(n => !known.has(n) && !as0.vars.includes(n));
+            if (out.length)
+                throw new Error(`${s.name}: an exists(...) in the assumption reads ${out[0]}: it reads only the params and the request (its value comes with the request)`);
+        }
+        skolemsOf.set(this, { params: pre0.bodies, inputs: as0.bodies });
+        params.push(...pre0.vars);
+        inputs.push(...as0.vars);
+        const pre = [...this.kindAssumptions('params'), ...pre0.cs];
+        const assume = [...this.kindAssumptions('inputs'), ...(s.lists2 ?? []).flatMap(([n]) => env[n].equations().map(c => hoist.cond(c.c))), ...as0.cs.map(c => hoist.cond(c))];
         placed();
         // Functions, and their facts: each function's own (named after it), then the rule's.
         // The functions a function reads come first, each named <function>.<use>.
@@ -2092,7 +2182,7 @@ export class Rule {
                 ...(s.prune ? { prune: { order: pruneOrder[0], after: termOf(s.prune.after(pEnv)) } } : {}),
             };
         }
-        return m;
+        return withArithmetic(m, [], s.arith ?? []);
     }
     // --- the builders checked ------------------------------------------------------------------------------------------
     // The builders against what they built, on concrete runs: random params and requests by their kinds (`pre` and
@@ -2267,7 +2357,26 @@ export class Rule {
     }
     // --- 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); }
+    encodeParams(values) { return this.withSkolems('params', encode(this.spec.params, values)); }
+    // The values the params or a request bring for the existentials of a precondition or the assumption: each a witness
+    // found (exact for one natural or integer read linearly), or 0 where none is (the precondition or the assumption then
+    // fails, so the params or the request are refused).
+    withSkolems(which, out, params) {
+        if (!skolemsOf.has(this))
+            void this.machine;
+        const sk = skolemsOf.get(this)?.[which] ?? [];
+        if (!sk.length)
+            return out;
+        const m = this.machine, env = { ...params, ...numbersOf(out) };
+        for (const b of sk) {
+            const w = someHolds(b.body, b.vars, env, { scalars: {}, maps: {} }, m)?.witness ?? {};
+            for (const n of b.vars) {
+                out[n] = w[n] ?? 0;
+                env[n] = w[n] ?? 0;
+            }
+        }
+        return out;
+    }
     // A carried map is a Set of keys (each cell 1), an array of them, or a Map of key to natural; a sequence an array of
     // naturals, a table of them an array of such arrays.
     // A carried list is an array of its items' runtime values (its length and folds computed from them); `params`, what
@@ -2303,7 +2412,7 @@ export class Rule {
             const given = values[n];
             out[n] = given instanceof Map ? new Map(given) : new Map([...given].map(key => [key, 1]));
         }
-        return out;
+        return this.withSkolems('inputs', out, params && this.encodeParams(params));
     }
     // Each carried list's folds at its end (what `L.fold.<f>` reads), computed from its items as encodeInput computes
     // them, without running the rule: `foldsOf({Lines: [...]})` → {Lines: {total: 30}}. Only the lists given.
@@ -2318,7 +2427,7 @@ export class Rule {
     // The state's variables declared with a kind (a yes/no, a choice, an integer...), with their kinds.
     kindsOfState() { return this.spec.kinded ?? []; }
     // 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))); }
+    randomParams(rand, bound) { return this.withSkolems('params', Object.assign({}, ...this.spec.params.map(([n, k]) => k.random(n, rand, bound)))); }
     // The params' values by their kinds, as constants (what a fold that reads them is computed with).
     paramValues(ps) {
         return Object.fromEntries(this.spec.params.map(([n, k]) => [n, k.build(n, part => new Term({ op: 'const', value: ps[part] }, ps[part]))]));
@@ -2333,7 +2442,7 @@ export class Rule {
             const l = new CarriedList(n, k, v(`${n}_len`), fs, part => new MapRef(part, 0), {}, ps && this.paramValues(ps)).encode(Array.from({ length: rand(bound + 1) }, () => k.sample(rand, bound)));
             Object.assign(out, l.maps, { [`${n}_len`]: l.len });
         }
-        return out;
+        return this.withSkolems('inputs', out, ps);
     }
     // The state's scalars as runtime values: each kinded variable as its kind decodes it (an integer as one signed
     // number, a decimal as its number, a choice by name, a string as itself, none as null).
@@ -2376,7 +2485,7 @@ const expandParts = (updates) => {
     return updates;
 };
 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: [] });
+export const rule = (name) => new Rule({ name, params: [], inputs: [], state: [], maps: [], flags: [], pre: [], assume: [], sums: [], queries: [], arith: new Set() });
 const quantifiedE = (e) => e.op === 'if' ? quantifiedIn(e.c) || quantifiedE(e.then) || quantifiedE(e.else) : 'a' in e && typeof e.a === 'object' ? quantifiedE(e.a) || ('b' in e && typeof e.b === 'object' && quantifiedE(e.b)) : false;
 const quantifiedIn = (c) => c.op === 'all' || (c.op === 'not' ? quantifiedIn(c.x) : c.op === 'and' || c.op === 'or' ? c.xs.some(quantifiedIn) : c.op === 'flag' ? false : quantifiedE(c.a) || quantifiedE(c.b));
 // The kind a result field is kept in.
@@ -2537,7 +2646,8 @@ const refuteBudget = { trials: 60, depth: 6, bound: 3, ms: 150 };
 const deeperBudget = { trials: 600, depth: 24, bound: 8, ms: 1500, seed: 29 };
 function refuteByRuns(r, laws, stepLaws = [], budget = refuteBudget) {
     const m = r.machine;
-    if (Object.keys(m.fns ?? {}).length || m.facts?.length)
+    // Division by a constant is a function too, but its facts fix its value, so a run computing it is a run of the rule.
+    if (Object.keys(m.fns ?? {}).some(f => !isArithmetic(f)) || m.facts?.some(f => !isArithmetic(f.name.slice(0, f.name.indexOf(':')))))
         return undefined;
     const run = interpret(m), rand = seeded(budget.seed ?? 13), until = performance.now() + budget.ms, bound = budget.bound;
     const shown = (input) => Object.fromEntries(Object.entries(input).map(([n, x]) => [n, typeof x === 'number' ? x : Object.fromEntries(x)]));
@@ -2602,15 +2712,21 @@ function refuteByRuns(r, laws, stepLaws = [], budget = refuteBudget) {
     return undefined;
 }
 const refutedVerdict = (out) => ({ proven: false, checked: false, goal: out.goal, stuck: 'sat', witness: out.witness, ...(out.run ? { run: out.run } : {}) });
+// The divisors some laws read (modBy, divBy), noted on the rule so its machine declares them: a law may come from
+// another instance of the same rule (a factory called twice).
+const noting = (r, ...xs) => { const ks = divisorsIn(xs); if (ks.size)
+    r.dividesBy(...ks); return r; };
 export function proveRule(r, laws, opts = {}) {
+    noting(r, laws);
     const refuted = refuteByRuns(r, laws);
     if (refuted)
         return refutedVerdict(refuted);
     const out = proveLaws(r.machine, withKinds(r, laws));
-    const v = { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}), ...(out.failed.why ? { why: out.failed.why } : {}) } : {}) };
+    const v = { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}), ...(out.failed.why ? { why: out.failed.why } : {}) } : {}), ...(out.witnesses && out.proven ? { witnesses: out.witnesses } : {}) };
     return searched(r, laws, [], v, opts);
 }
 export function proveSteps(r, laws, stepLaws, opts = {}) {
+    noting(r, laws, stepLaws);
     const refuted = refuteByRuns(r, laws, stepLaws);
     if (refuted)
         return refutedVerdict(refuted);
@@ -2654,7 +2770,15 @@ function searched(r, laws, stepLaws, v, opts) {
     void _stats;
     return { ...verdict, found: { laws: found, ...(lemmas ? { lemmas } : {}) } };
 }
-export function proveLeadsTo(r, laws, l) {
+export function proveLeadsTo(r, laws, l, opts = {}) {
+    noting(r, laws, l);
+    if (laws.some(law => law.some?.length))
+        throw new Error(`${r.machine.name}: a law with "there exists" goes to proveRule or proveSteps; a liveness takes plain laws (the ones its proof printed, Verdict.witnesses)`);
+    if (Array.isArray(l.rank) && !l.rank.length) {
+        const f = findLeadsTo(r.machine, withKinds(r, laws), l, { params: (rand, bound) => r.randomParams(rand, bound), input: (rand, bound, ps) => r.randomInput(rand, bound, ps) }, opts);
+        return { proven: f.proven, checked: f.checked, ...(f.goal ? { goal: f.goal, stuck: f.stuck } : {}), ...(f.witness ? { witness: f.witness } : {}), ...(f.why ? { why: f.why } : {}),
+            ...(f.found ? { found: { rank: f.found.rank, ...(f.laws?.length ? { laws: f.laws.map((law, i) => ({ law, text: f.found.laws[i] ?? law.name })) } : {}) } } : {}) };
+    }
     const out = proveLiveness(r.machine, withKinds(r, laws), l);
     return { proven: out.proven, checked: out.checked, ...(out.failed ? { goal: out.failed.goal, stuck: out.failed.stuck, ...(out.failed.witness ? { witness: out.failed.witness } : {}), ...(out.failed.why ? { why: out.failed.why } : {}) } : {}) };
 }
@@ -2691,7 +2815,7 @@ export function crossCheckDecision(d, opts = {}) {
 // needs (inferLaws), within `ms` (10 s); the verdict is the kernel's on the rank and the laws found, in `found`.
 export const proveLoop = (l, laws, opts = {}) => {
     if (cyclicOn() || certOn())
-        cycLog({ kind: 'loop', name: l.loop.name, uncovered: true, why: 'a claim about runs that never end' });
+        uncovered('loop', l.loop.name, 'a claim about runs that never end');
     if (l.hasRank)
         return goalsVerdict(loopObligations(l.loop, laws, l.rankTerms));
     const out = findRank(l.loop, laws, opts);
@@ -2813,12 +2937,18 @@ export class FoldRule {
 export const fold = (name) => new FoldRule({ name, params: [], inputs: [], pre: [], assume: [] });
 // A fold's laws proven over every tree (a rose fold's own laws, its children's lemmas, with them).
 export const proveFold = (f, laws) => {
-    // (GDP_CERT=cyclic: the certificate a cyclic proof, core/cyclic.ts's certCyclic, the usual trees its input)
+    // (by default the certificate a cyclic proof, core/cyclic.ts's certCyclic, the usual trees its input; where none is
+    // made, the usual trees checked)
     const all = [...(f.lemmas ?? []), ...laws], t0 = performance.now(), v = goalsVerdict(foldObligations(f.fold, all), !certOn()), usualMs = performance.now() - t0;
     if (cyclicOn())
         crossCyclic('fold', f.fold.name, v.proven && v.checked, () => { const { facts, specs } = foldNodes(f.fold, all); return proveCyclic(facts, specs); }, usualMs, v.trees && (st => translatedProof(() => JSON.stringify(['fold', f.fold, all]), () => foldNodes(f.fold, all, v.trees, st), st)));
-    if (certOn() && v.proven)
-        v.checked = certCyclic('fold', f.fold.name, v.trees && (st => translatedProof(() => JSON.stringify(['fold', f.fold, all]), () => foldNodes(f.fold, all, v.trees, st), st)), () => { const { facts, specs } = foldNodes(f.fold, all); return proveCyclic(facts, specs); }, usualMs).checked;
+    if (certOn() && v.proven) {
+        const c = certCyclic('fold', f.fold.name, v.trees && (st => translatedProof(() => JSON.stringify(['fold', f.fold, all]), () => foldNodes(f.fold, all, v.trees, st), st)), () => { const { facts, specs } = foldNodes(f.fold, all); return proveCyclic(facts, specs); }, usualMs);
+        if (!c.checked) {
+            uncovered('fold', f.fold.name, c.why);
+            v.checked = foldObligations(f.fold, all).every(g => v.trees?.[g.name] !== undefined && check(g, v.trees[g.name]));
+        }
+    }
     return v;
 };
 const asTerm = (t) => (t instanceof Term ? t : lit(t));

package/dist/core/exists.d.ts

@@ -0,0 +1,26 @@
+import { type C, type E, type Law, type Machine, type SomeWitness, type State } from './machine.js';
+import { type Report } from '../kernel/prove.js';
+type Env = Record<string, number>;
+type Group = string[];
+export declare const namesOf: (t: E | C) => string[];
+export declare function groupsOf(vars: string[]): Group[];
+export declare function substVarsE(e: E, s: Record<string, E>): E;
+export declare function substVars(c: C, s: Record<string, E>): C;
+export declare function someHolds(body: C, vars: string[], env: Env, st: State, m: Machine): {
+    holds: boolean;
+    witness?: Env;
+} | undefined;
+export type SomeReport = Report & {
+    laws?: Law[];
+    machine?: Machine;
+    ghosts?: string[];
+    witnesses?: Record<string, string>;
+    proof?: unknown;
+};
+export declare function proveSome(m: Machine, laws: Law[], opts?: {
+    rounds?: number;
+}): SomeReport;
+export declare function showE(e: E): string;
+export declare function showC(c: C): string;
+export declare const someLaws: (laws: Law[]) => boolean;
+export type { SomeWitness };