gdp-wired 0.12.1 → 0.12.2

package/dist/core/solver.js

@@ -100,7 +100,12 @@ export function solve(constraints, maxRows = 20_000) {
             const neg = byKey.get(negKey(r));
             if (neg === undefined || neg === r)
                 continue;
-            const x = vars(lins[r]).find(name => Math.abs(lins[r][name]) === 1);
+            let x;
+            for (const name in lins[r])
+                if (name !== '1' && Math.abs(lins[r][name]) === 1) {
+                    x = name;
+                    break;
+                }
             if (x === undefined)
                 continue;
             // up: the row of the pair with +x, down: with −x.
@@ -139,9 +144,10 @@ export function solve(constraints, maxRows = 20_000) {
         // Each variable's rows by sign, in one pass (variables in the order they first appear).
         const index = new Map();
         for (const r of rows)
-            for (const [x, c] of Object.entries(lins[r])) {
+            for (const x in lins[r]) {
                 if (x === '1')
                     continue;
+                const c = lins[r][x];
                 let e = index.get(x);
                 if (!e)
                     index.set(x, (e = { pos: [], neg: [], posUnit: true, negUnit: true }));

package/dist/kernel/kernel.js

@@ -1120,7 +1120,7 @@ export function stepLawObligations(machine, laws, instances, sl) {
     const m = machine.history ? historyMachine(machine).machine : machine;
     scope(m, laws);
     const k = sl.steps ?? 1;
-    // Past 64 the cost is the bound (proving grows about as k³: 64 steps in about 17 s on Modal; Lean checks 32 in about 25 s, 64 in about 3 minutes).
+    // Past 64 the cost is the bound (proving grows about as k³: 64 steps in about 5 s on Modal; Lean checks 32 in about 14 s, 64 in about 47 s).
     if (!Number.isInteger(k) || k < 1 || k > 64)
         throw new Error(`step law ${sl.name}: steps is a whole number from 1 to 64`);
     const whens = sl.when === undefined ? [] : Array.isArray(sl.when) ? sl.when : [sl.when];

package/dist/kernel/prove.js

@@ -412,15 +412,25 @@ function growFocused(goal, path, focus, budget, near = focus) {
 }
 // A refutation from the rows near some facts (the rows reachable from their variables in two hops, each row joining the
 // variables it reads), its inputs renumbered to the whole leaf's. A cut about one step of a long run needs that step's
-// rows, not the run's; a cut it misses is only a cut not made (the plain search still follows).
+// rows, not the run's; a cut it misses is only a cut not made (the plain search still follows). A variable most rows
+// read (a param every step reads) joins no rows: through it every step is near every other.
 function solveNear(rows, seeds) {
+    const uses = new Map();
+    for (const r of rows)
+        for (const key in r.lin)
+            if (key !== '1')
+                uses.set(key, (uses.get(key) ?? 0) + 1);
+    const hub = (key) => (uses.get(key) ?? 0) > Math.max(16, rows.length / 8);
     const reach = new Set(seeds.flatMap(l => Object.keys(l).filter(key => key !== '1')));
-    for (let hop = 0; hop < 2; hop++)
+    for (let hop = 0; hop < 2; hop++) {
+        // One hop: the rows reading what was reached before it (not what this hop adds, or one pass runs along the run).
+        const from = new Set(reach);
         for (const r of rows) {
             const keys = Object.keys(r.lin).filter(key => key !== '1');
-            if (keys.some(key => reach.has(key)))
+            if (keys.some(key => from.has(key) && !hub(key)))
                 keys.forEach(key => reach.add(key));
         }
+    }
     const picked = rows.flatMap((r, i) => (Object.keys(r.lin).every(key => key === '1' || reach.has(key)) ? [i] : []));
     const near = solve(picked.map(i => rows[i]));
     return near.kind === 'refuted' ? { kind: 'refuted', steps: near.steps.map(st => (st.kind === 'input' ? { ...st, index: picked[st.index] } : st)) } : near;