gdp-wired 0.12.6 → 0.12.7

package/README.md

@@ -316,7 +316,7 @@ const soon = retry.law('the next try is at most 64 after the last request', ({ne
 - **Running it**: `rule.interpreter()` is persistent (searches branch from any state); `rule.compiled()` is what an app
   ships: maps and the log updated in place, so a step costs the same however long the history. Both refuse params and
   inputs that aren't naturals below 2^53 and any value past 2^53 − 1, where the proofs over the naturals stop describing
-  the run. The GPU searches refuse a space whose values could pass 2^32 − 1.
+  the run, and a request that fails the rule's `assume` (no proof covers the step it would take). The GPU searches refuse a space whose values could pass 2^32 − 1.
 
 ## Numbers
 

package/dist/core/dsl.js

@@ -2126,7 +2126,7 @@ export class Rule {
     // with requests drawn by their kinds (or `draw`), must hold the same values as the compiled rule (decoded: integers and
     // decimals as numbers) for every field the reference's state has, after every step of `trials` runs of `depth`.
     compare(reference, opts = {}) {
-        const s = this.spec, rand = opts.rand ?? seeded(5), bound = opts.bound ?? 100, gen = this.compiled();
+        const s = this.spec, rand = opts.rand ?? seeded(5), bound = opts.bound ?? 100, gen = this.compiled(), run = interpret(this.machine);
         let checked = 0;
         const sample = (kinds) => Object.fromEntries(kinds.map(([n, k]) => [n, k.sample(rand, bound)]));
         for (let trial = 0; trial < (opts.trials ?? 200); trial++) {
@@ -2134,8 +2134,11 @@ export class Rule {
             let ours = gen.init(ps), theirs = reference.init(params);
             const edges = trial === 0 ? opts.edges ?? [] : [];
             for (let d = 0; d < (opts.depth ?? 10) + edges.length; d++) {
-                const request = edges[d] ?? opts.draw?.(rand) ?? sample(s.inputs);
-                ours = gen.step(ps, ours, this.encodeInput(request, params));
+                const request = edges[d] ?? opts.draw?.(rand) ?? sample(s.inputs), encoded = this.encodeInput(request, params);
+                // A request the rule's assumption refuses is no step of the rule: the runtimes throw, so it isn't compared.
+                if (!allowed(this.machine, run, ps, ours, encoded))
+                    continue;
+                ours = gen.step(ps, ours, encoded);
                 theirs = reference.step(params, theirs, request);
                 const got = this.decode(ours);
                 for (const [field, want] of Object.entries(theirs)) {

package/dist/core/machine.js

@@ -272,6 +272,9 @@ export function carriedView(m, st, input, rename = map => map) {
 }
 // A request's numbers (its inputs), without the maps it carries.
 export const numbersOf = (input) => Object.fromEntries(Object.entries(input).filter((e) => typeof e[1] === 'number'));
+// A request the rule's assumption refuses: the proofs say nothing about the step it would take, so neither runtime takes
+// it (a caller that may send one checks first, as gdp-wired/gdp's gate does).
+const refused = (m) => `${m.name}: the request fails the rule's assumption, so no proof covers the step it would take`;
 // The interpreter: persistent (a step leaves the state it was given as it was), so searches can branch from any state.
 export function interpret(m) {
     const { h, plain, carried } = runnable(m);
@@ -340,6 +343,8 @@ export function interpret(m) {
             }
             for (const [name, c] of Object.entries(plain.step.flags ?? {}))
                 env[`?${name}`] = evalC(c, env, st, plain) ? 1 : 0;
+            if (m.assume && !evalC(m.assume, env, st, plain))
+                throw new RangeError(refused(m));
             const scalars = { ...st.scalars };
             for (const [name, e] of Object.entries(plain.step.state ?? {}))
                 scalars[name] = evalE(e, env, st, plain);
@@ -371,6 +376,8 @@ const RUNTIME = [
     ['$m', `function $m(v, what) { if (!(v instanceof Map)) throw new RangeError(what + ' must be a Map of naturals'); for (const [key, x] of v) { $n(key, 'a key of ' + what); $n(x, 'a cell of ' + what); } return v; }`],
     ['$keys', `function $keys(maps, names) { const keys = new Set(); let past = 0; for (const c of Object.values(maps)) for (const key of c.keys()) past = Math.max(past, key + 1); for (const n of names) for (const key of maps[n].keys()) keys.add(key); return [...keys, past]; }`],
     ['$breaks', `function $breaks(maps, reads, cmps) { const p = new Set([0]); for (const [n, d, minus] of reads) { for (const s of maps[n].keys()) { if (minus) p.add(s + d); else if (s >= d) p.add(s - d); } if (minus) p.add(d); } for (const [v, d, minus] of cmps) { if (minus) { p.add(v + d); p.add(d); } else if (v >= d) p.add(v - d); } const keys = new Set(); for (const q of p) for (let i = -1; i <= 2; i++) if (q + i >= 0) keys.add(q + i); const sorted = [...keys].sort((a, b) => a - b); sorted.push(sorted[sorted.length - 1] + 1); return sorted; }`],
+    // A condition at every two keys that holds wherever x(k) differs from y(k1): only the pairs whose values match are read.
+    ['$join', `function $join(ks, x, y, f) { const by = new Map(); for (const k1 of ks) { const v = y(k1), l = by.get(v); if (l) l.push(k1); else by.set(v, [k1]); } return ks.every(k => { const l = by.get(x(k)); return l === undefined || l.every(k1 => f(k, k1)); }); }`],
     ['$spread', `function $spread(keys, n) { const out = new Set(); for (const k of keys) for (let i = 0; i < n; i++) out.add(k + i); return [...out].sort((a, b) => a - b); }`],
     ['$dense', `function $dense(keys, f) { const top = keys[keys.length - 1]; if (top > 1000000) throw new RangeError('a write at every key reads its key in arithmetic past a million keys (' + top + ')'); const d = f(top), cells = new Map(); for (let k = 0; k < top; k++) { const v = f(k); if (v !== d) cells.set(k, v); } return {cells, d}; }`],
     ['$every', `function $every(keys, f) { const past = keys[keys.length - 1], d = f(past), cells = new Map(); for (let i = 0; i < keys.length - 1; i++) { const v = f(keys[i]); if (v !== d) cells.set(keys[i], v); } return {cells, d}; }`],
@@ -388,6 +395,22 @@ function runtimeFor(code) {
     }
     return RUNTIME.filter(([name]) => used.has(name)).map(([, src]) => `${src}\n`).join('');
 }
+// A condition over two keys, k and k1, that holds wherever a term of k alone differs from a term of k1 alone: an
+// implication (a not-and, or an or with one) whose premises include x(k) = y(k1). The runtime then reads only the pairs
+// whose values match ($join), the rest holding by the premise: rows plus matches, not rows squared.
+function joinOf(c, k, k1) {
+    const reads = (t, key) => JSON.stringify(t).includes(`"op":"var","name":${JSON.stringify(key)}`);
+    const premises = c.op === 'not' && c.x.op === 'and' ? c.x.xs : c.op === 'or' ? c.xs.flatMap(x => (x.op === 'not' ? (x.x.op === 'and' ? x.x.xs : [x.x]) : [])) : [];
+    for (const p of premises) {
+        if (p.op !== '=')
+            continue;
+        if (reads(p.a, k) && !reads(p.a, k1) && reads(p.b, k1) && !reads(p.b, k))
+            return { x: p.a, y: p.b };
+        if (reads(p.b, k) && !reads(p.b, k1) && reads(p.a, k1) && !reads(p.a, k))
+            return { x: p.b, y: p.a };
+    }
+    return undefined;
+}
 export function compileJs(m) {
     const { h, plain, queries, carried } = runnable(m);
     const id = (name) => JSON.stringify(name);
@@ -427,6 +450,15 @@ export function compileJs(m) {
                 bound = { ...bound, ...Object.fromEntries(names.map((n, i) => [n, ks[i]])) };
                 const body = cx(c.c);
                 bound = outer;
+                if (names.length === 2) {
+                    const j = joinOf(c.c, names[0], names[1]);
+                    if (j) {
+                        bound = { ...bound, [names[0]]: 'k', [names[1]]: 'k1' };
+                        const x = ex(j.x), y = ex(j.y);
+                        bound = outer;
+                        return `$join(${keys}, k => ${x}, k1 => ${y}, (k, k1) => ${body})`;
+                    }
+                }
                 return names.length === 1 ? `${keys}.every(k => ${body})` : `(ks => ${ks.map(k => `ks.every(${k} => `).join('')}${body}${')'.repeat(ks.length)})(${keys})`;
             }
         }
@@ -465,7 +497,9 @@ export function compileJs(m) {
         }
         lines.push(`let ${queries.map((_, i) => `q${i} = 0`).join(', ')};`, `for (let i = head; i < records.length; i++) { const r = records[i]; ${queries.map((q, i) => `q${i} = $x(q${i} + ${ex(h.queries[q])});`).join(' ')} }`, ...queries.map((q, i) => `env[${id(q)}] = q${i};`));
     }
-    lines.push(...flags.map((name, i) => `const flag${i} = ${cx(plain.step.flags[name])};`), `const scalars = {...s, ${Object.entries(plain.step.state ?? {}).map(([name, e]) => `${id(name)}: ${ex(e)}`).join(', ')}};`, ...writes.map(([, w], i) => ('each' in w ? `const write${i} = ${every(w)};` : `const key${i} = ${ex(w.key)}, value${i} = ${ex(w.value)};`)));
+    lines.push(...flags.map((name, i) => `const flag${i} = ${cx(plain.step.flags[name])};`), 
+    // The rule's own assumption, as `allowed` (core/watch.ts) reads it (a history's machine assumes more: its relations).
+    ...(m.assume ? [`if (!${cx(m.assume)}) throw new RangeError(${id(refused(m))});`] : []), `const scalars = {...s, ${Object.entries(plain.step.state ?? {}).map(([name, e]) => `${id(name)}: ${ex(e)}`).join(', ')}};`, ...writes.map(([, w], i) => ('each' in w ? `const write${i} = ${every(w)};` : `const key${i} = ${ex(w.key)}, value${i} = ${ex(w.value)};`)));
     if (h)
         lines.push(`const keep = ${cx(h.keep)};`);
     lines.push(...writes.map(([name, w], i) => ('each' in w ? `state.maps[${id(name)}] = write${i}.cells; dft[${id(name)}] = write${i}.d;` : `state.maps[${id(name)}].set(key${i}, value${i});`)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdp-wired",
-  "version": "0.12.6",
+  "version": "0.12.7",
   "description": "An automatic prover for stateful rules (budgets, caps, windows, workflows, policies): laws proven with no proof to write, checked again in Lean, counterexamples found on the GPU, the rule shipped as code",
   "keywords": [
     "verification",