gdp-wired 0.12.0 → 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

@@ -210,6 +210,13 @@ function growPlain(goal, path, budget) {
     const verdict = next && rows.length > 60 ? solveP(rows, 2 * rows.length) : solveP(rows);
     if (verdict.kind === 'refuted')
         return { tree: leafOf(verdict.steps), nodes: budget.nodes };
+    // Before a split, the rows the plain search sets aside (those reading a term column) by their Farkas rows: an open
+    // choice's bounds (min(a, c) ≤ c) often refute the case whichever way the choice goes, so its cases need no split.
+    if (next && !columns && full.length > rows.length) {
+        const fast = timed(() => refuteFast(full), ms => { profile.solves++; profile.solveMs += ms; });
+        if (fast?.kind === 'refuted')
+            return { tree: { leaf: fast.steps }, nodes: budget.nodes };
+    }
     let split = next ?? (verdict.kind === 'unknown' ? bisect(rows, path) ?? fractional(verdict.point, path) : undefined);
     // Products: with monomials about, try every pair of rows multiplied; failing that, split a factor at zero.
     const monomials = rows.some(r => Object.keys(r.lin).some(key => key.includes('*')));
@@ -405,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;

package/dist/lean-kernel/emit.js

@@ -137,7 +137,7 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
             coefs.pop();
         return coefs;
     };
-    // Rows by their nonzero coefficients (Kernel.lean's sp builds the dense row): most of a wide row is zeros.
+    // Rows by their nonzero coefficients (Cert.lean's rows hold them so): most of a wide row is zeros.
     const sparse = (coefs) => list(coefs.flatMap((x, j) => (x === 0 ? [] : [`(${j}, ${int(x)})`])));
     const row = (lin) => `(sp ${sparse(dense(lin))} ${int(lin['1'] ?? 0)})`;
     const { e, c } = leanTerms(vars, maps, ex.name);
@@ -173,7 +173,7 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
             const q = Object.fromEntries(Object.entries(from).filter(([key]) => key !== '1').map(([key, v]) => [key, v / s.g]));
             const cc = Math.ceil((from['1'] ?? 0) / s.g);
             replay.push({ ...q, 1: cc });
-            return `.cut ${s.of} ${int(s.g)} (sparseL 0 ${sparse(dense(q))}) ${int(cc)}`;
+            return `.cut ${s.of} ${int(s.g)} ${sparse(dense(q))} ${int(cc)}`;
         });
         if (tamper && dropStep && leafNo++ === 0)
             steps = steps.slice(0, -1); // the first leaf loses its last step