gdp-wired 0.14.1 → 0.15.0

package/dist/kernel/kernel.js

@@ -212,11 +212,11 @@ export function termRows(name, path) {
         }
     }
     // An if is one of its two naturals, so at most their sum, whichever way its condition goes (a yes/no's if(c, 1, 0)
-    // is at most 1 without deciding c). Only over branches that read no term column: one that did would bring that
-    // column's rows into the leaf, and theirs, through every if a run of steps nests.
+    // is at most 1 without deciding c). Only over constant branches: over a variable one (a map's if(c, Given[k], 0)),
+    // each such row is one more in every leaf and slows the solve more than it saves.
     if (e.op === 'if') {
-        const a = linear(e.then, path), b = linear(e.else, path), plain = (l) => Object.keys(l).every(key => !key.startsWith('⟦'));
-        if (a && b && plain(a) && plain(b))
+        const a = linear(e.then, path), b = linear(e.else, path), constant = (l) => Object.entries(l).every(([key, c]) => key === '1' || c === 0);
+        if (a && b && constant(a) && constant(b))
             out.push(sub(col, add(a, b)));
     }
     if (decided(e, path)) {
@@ -226,20 +226,46 @@ export function termRows(name, path) {
     }
     return out;
 }
-// Products: multiply out, each monomial (variables joined by '*', sorted) one more natural variable. Forgetting how
-// monomials relate (x*x to x, say) only weakens what a leaf may use, so it stays sound; distributing is what proves
-// spend <= m·count over a node from the same law at its children. Map reads can't be factors.
+// Products: multiply out, each monomial (its factors joined by '*', sorted) one more natural variable. A factor is a
+// variable or a map's cell (used ≤ per·Seats[k] reads one); an open choice isn't (the path decides it first, and the
+// product is of its branch). Forgetting how monomials relate (x*x to x, say, or two monomials over cells the path
+// proves equal) only weakens what a leaf may use, so it stays sound; distributing is what proves spend <= m·count over
+// a node from the same law at its children.
 function times(a, b) {
     const out = [];
     for (const [p, cp] of Object.entries(a))
         for (const [q, cq] of Object.entries(b)) {
-            if (p.includes('[') || q.includes('[') || p.includes('⟦') || q.includes('⟦'))
-                return undefined; // factors are variables (and monomials of them)
-            const factors = [...(p === '1' ? [] : p.split('*')), ...(q === '1' ? [] : q.split('*'))].sort();
-            out.push({ [factors.length ? factors.join('*') : '1']: cp * cq });
+            if (p.includes('⟦') || q.includes('⟦'))
+                return undefined;
+            const fs = [...(p === '1' ? [] : factorsOf(p)), ...(q === '1' ? [] : factorsOf(q))].sort();
+            out.push({ [fs.length ? fs.join('*') : '1']: cp * cq });
         }
     return add(...out);
 }
+// A name's factors: split at each '*' outside a cell's brackets (a cell's key may itself read a monomial).
+const factorMemo = new Map();
+export function factorsOf(name) {
+    let out = factorMemo.get(name);
+    if (out)
+        return out;
+    out = [];
+    let depth = 0, start = 0;
+    for (let i = 0; i <= name.length; i++) {
+        const ch = name[i];
+        if (ch === '[')
+            depth++;
+        else if (ch === ']')
+            depth--;
+        else if ((ch === '*' && depth === 0) || i === name.length) {
+            out.push(name.slice(start, i));
+            start = i + 1;
+        }
+    }
+    factorMemo.set(name, out);
+    return out;
+}
+export const isMonomial = (name) => factorsOf(name).length > 1;
+export const isCell = (name) => name.includes('[') && !isMonomial(name);
 const comparisonMemo = new WeakMap(), freeComparison = new WeakMap();
 function comparison(c, path) {
     const free = choiceFree(c.a) && choiceFree(c.b);
@@ -426,7 +452,7 @@ function leafRows(goal, path, factsOf) {
             rows.push({ lin, label: '', src: { fact: i } });
     const names = new Set(rows.flatMap(r => Object.keys(r.lin).filter(key => key !== '1')));
     // Two reads of one map whose keys the path proves equal are equal.
-    const cells = [...names].filter(name => name.includes('[')).map(name => ({ name, map: name.slice(0, name.indexOf('[')), key: keyOf(name) }));
+    const cells = [...names].filter(isCell).map(name => ({ name, map: name.slice(0, name.indexOf('[')), key: keyOf(name) }));
     for (const [i, p] of cells.entries())
         for (const q of cells.slice(i + 1)) {
             if (p.map !== q.map)
@@ -480,10 +506,16 @@ const keyOf = (cell) => {
     }
     return out;
 };
-// A leaf may also use the product of two of its rows: p <= 0 and q <= 0 give p·q >= 0, as nlinarith does. A pair may
-// name an earlier product row too (index past the leaf's rows), which is a row of the same kind, so degrees go higher.
-export function withProducts(rows, pairs) {
+// A leaf may also use the product of two of its rows: p <= 0 and q <= 0 give p·q >= 0, as nlinarith does; and the
+// square of any linear form t, which holds whatever t's sign: t·t >= 0 (a sum of squares, as a Positivstellensatz
+// certificate has). The squares follow the leaf's rows, then the products; a pair may name a square or an earlier
+// product (an index past the leaf's rows), each a row of the same kind, so degrees go higher.
+export function withProducts(rows, pairs, squares = []) {
     const out = [...rows];
+    for (const t of squares) {
+        const tt = times(t, t);
+        out.push(tt ? { lin: scale(tt, -1), label: '' } : { lin: {}, label: '' });
+    }
     for (const [i, j] of pairs) {
         const p = out[i], q = out[j], pq = p && q ? times(p.lin, q.lin) : undefined;
         out.push(pq ? { lin: scale(pq, -1), label: '' } : { lin: {}, label: '' });
@@ -492,7 +524,7 @@ export function withProducts(rows, pairs) {
 }
 export function check(goal, tree, path = new Map()) {
     if ('leaf' in tree)
-        return checkRefutation(withProducts(leafConstraints(goal, path), tree.products ?? []), tree.leaf);
+        return checkRefutation(withProducts(leafConstraints(goal, path), tree.products ?? [], tree.squares), tree.leaf);
     const id = canon(tree.split);
     if (path.has(id) || Object.keys(tree.split).every(key => key === '1'))
         return false;

package/dist/kernel/prove.d.ts

@@ -53,6 +53,14 @@ export declare function proveLaws(m: Machine, laws: Law[]): Report & {
         trees: Record<string, Tree>;
     };
 };
+export declare function proveLaw(m: Machine, laws: Law[], i: number): {
+    proven: true;
+} | {
+    proven: false;
+    goal: string;
+    stuck: string;
+    witness?: Record<string, number>;
+};
 type StepProof = {
     laws: {
         instances: Record<string, Instances>;

package/dist/kernel/prove.js

@@ -1,5 +1,5 @@
 import { add, k, refuteFast, scale, solve, sub, v } from "../core/solver.js";
-import { assumed, boundOf, canon, canonFlip, columnTerm, decided, stepZone, check, checkLaws, checkStepLaws, historyMachine, leafConstraints, leafConstraintsReusing, reusing, linear, livenessHelpful, livenessParts, obligations, plainKey, progressObligations, stepLawObligations, trueC, truth, unreachable, witnessesOf, withProducts } from "./kernel.js";
+import { assumed, boundOf, canon, canonFlip, columnTerm, decided, factorsOf, isCell, isMonomial, stepZone, check, checkLaws, checkStepLaws, historyMachine, leafConstraints, leafConstraintsReusing, reusing, linear, livenessHelpful, livenessParts, obligations, plainKey, progressObligations, stepLawObligations, trueC, truth, unreachable, witnessesOf, withProducts } from "./kernel.js";
 // The atoms the path leaves open, in evaluation order: deciding any of them makes progress.
 function openE(e, path, out) {
     switch (e.op) {
@@ -78,7 +78,7 @@ function openH(c, path, out, positive = true) {
 }
 // Pairs of reads of one map whose keys the path doesn't yet compare.
 function openCells(rows, path) {
-    const names = [...new Set(rows.flatMap(r => Object.keys(r.lin)))].filter(n => n.includes('['));
+    const names = [...new Set(rows.flatMap(r => Object.keys(r.lin)))].filter(isCell);
     const out = [];
     const keyText = (n) => n.slice(n.indexOf('[') + 1, -1);
     for (const [i, p] of names.entries())
@@ -181,7 +181,10 @@ function growPlain(goal, path, budget) {
     const columns = [...path.values()].some(a => Object.keys(a.lin).some(key => key.startsWith('⟦')));
     const idx = full.flatMap((r, i) => (columns || !Object.keys(r.lin).some(key => key.startsWith('⟦')) ? [i] : []));
     const rows = idx.map(i => full[i]), at = (i) => (i < rows.length ? idx[i] : full.length + i - rows.length);
-    const leafOf = (steps, products) => ({ leaf: steps.map(st => (st.kind === 'input' ? { ...st, index: at(st.index) } : st)), ...(products ? { products: products.map(([i, j]) => [at(i), at(j)]) } : {}) });
+    const leafOf = (steps0, products0, squares0) => {
+        const { steps, products, squares } = products0 || squares0 ? trimmed(rows.length, steps0, products0 ?? [], squares0 ?? []) : { steps: steps0, products: undefined, squares: undefined };
+        return { leaf: steps.map(st => (st.kind === 'input' ? { ...st, index: at(st.index) } : st)), ...(products?.length ? { products: products.map(([i, j]) => [at(i), at(j)]) } : {}), ...(squares?.length ? { squares } : {}) };
+    };
     // The conclusion's own atoms first (the goal's last hypothesis is the law refuted): a case it doesn't read is often
     // one no refutation needs, and splitting it first multiplies every case after it.
     const open = [];
@@ -226,18 +229,18 @@ function growPlain(goal, path, budget) {
     }
     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('*')));
+    const monomials = rows.some(r => Object.keys(r.lin).some(isMonomial));
     // A witness that multiplies out (each monomial's value is its factors' product) is a real model: nothing to refute.
     if (!split && monomials && verdict.kind === 'sat') {
         const w = verdict.witness, value = (key) => w[key] ?? 0;
-        const real = rows.every(r => Object.keys(r.lin).every(key => !key.includes('*') || value(key) === key.split('*').reduce((acc, f) => acc * value(f), 1)));
+        const real = rows.every(r => Object.keys(r.lin).every(key => !isMonomial(key) || value(key) === factorsOf(key).reduce((acc, f) => acc * value(f), 1)));
         if (real)
             return { stuck: 'sat', witness: w, path };
     }
     if (!split && monomials && rows.length <= 40) {
-        // Only rows about the factors (no map cells), each pair once: elimination over hundreds of products blows up.
-        const factorSet = new Set(rows.flatMap(r => Object.keys(r.lin).filter(key => key.includes('*')).flatMap(key => key.split('*'))));
-        const relevant = rows.flatMap((r, i) => (Object.keys(r.lin).every(key => key === '1' || (!key.includes('[') && key.split('*').every(f => factorSet.has(f)))) ? [i] : []));
+        // Only rows about the factors (no other map cells), each pair once: elimination over hundreds of products blows up.
+        const factorSet = new Set(rows.flatMap(r => Object.keys(r.lin).filter(isMonomial).flatMap(factorsOf)));
+        const relevant = rows.flatMap((r, i) => (Object.keys(r.lin).every(key => key === '1' || factorsOf(key).every(f => factorSet.has(f))) ? [i] : []));
         const pairs = [];
         for (const [a, i] of relevant.entries())
             for (const j of relevant.slice(a))
@@ -247,18 +250,40 @@ function growPlain(goal, path, budget) {
         if (product.kind === 'refuted')
             return { tree: leafOf(product.steps, pairs), nodes: budget.nodes };
         // Degree three: each row times each product of two variables (x·y >= 0 is the pair of -x <= 0 and -y <= 0).
-        const degree = Math.max(...rows.flatMap(r => Object.keys(r.lin).map(key => (key === '1' ? 0 : key.split('*').length))));
+        const degree = Math.max(...rows.flatMap(r => Object.keys(r.lin).map(key => (key === '1' ? 0 : factorsOf(key).length))));
         if (degree >= 3) {
-            const signs = rows.flatMap((r, i) => (Object.keys(r.lin).length === 1 && Object.values(r.lin)[0] < 0 && !Object.keys(r.lin)[0].includes('*') && !Object.keys(r.lin)[0].includes('[') ? [i] : []));
+            const signs = rows.flatMap((r, i) => { const key = Object.keys(r.lin)[0]; return Object.keys(r.lin).length === 1 && Object.values(r.lin)[0] < 0 && !isMonomial(key) && (!isCell(key) || factorSet.has(key)) ? [i] : []; });
             const sq = signs.flatMap((i, a) => signs.slice(a).map(j => [i, j])), cubes = [];
             for (let s = 0; s < sq.length; s++)
                 for (let i = 0; i < rows.length; i++)
                     cubes.push([rows.length + s, i]);
-            const third = solve(withProducts(rows, [...sq, ...cubes]));
+            const third = solve(withProducts(rows, [...sq, ...cubes, ...pairs]));
             if (third.kind === 'refuted')
-                return { tree: leafOf(third.steps, [...sq, ...cubes]), nodes: budget.nodes };
+                return { tree: leafOf(third.steps, [...sq, ...cubes, ...pairs]), nodes: budget.nodes };
+        }
+        // Sums of squares: each product the hypotheses multiply, x·y, gives (x − y)² >= 0, its factors as the path reads them
+        // (4·a'·b' <= (a' + b')² after a step that moves one from b to a is (a − b + 2)²); and each monomial written as u·w,
+        // u and w of half its degree (one factor set aside when the degree is odd), gives (u − w)² >= 0. With the pairs above,
+        // one solve finds a certificate of degree two in those forms (Cauchy–Schwarz's (ad − bc)²); past degree two, each
+        // square times each factor's sign too (a³ + b³ + c³ − 3abc is a sum of a·(b − c)² and the like).
+        const squares = [...new Map([...productForms(goal, path), ...squareForms(rows)].map(t => [canon(t), t])).values()].slice(0, 64);
+        if (squares.length) {
+            // The squares alone first (a small system), then with the pairs.
+            const alone = solve(withProducts(rows, [], squares));
+            if (alone.kind === 'refuted')
+                return { tree: leafOf(alone.steps, [], squares), nodes: budget.nodes };
+            const sos = solve(withProducts(rows, pairs, squares));
+            if (sos.kind === 'refuted')
+                return { tree: leafOf(sos.steps, pairs, squares), nodes: budget.nodes };
+            if (degree >= 3) {
+                const signs = rows.flatMap((r, i) => { const key = Object.keys(r.lin)[0]; return Object.keys(r.lin).length === 1 && Object.values(r.lin)[0] < 0 && factorSet.has(key) ? [i] : []; });
+                const weighted = [...pairs, ...signs.flatMap(i => squares.map((_, s) => [i, rows.length + s]))].slice(0, 600);
+                const third = solve(withProducts(rows, weighted, squares));
+                if (third.kind === 'refuted')
+                    return { tree: leafOf(third.steps, weighted, squares), nodes: budget.nodes };
+            }
         }
-        const factors = [...new Set(rows.flatMap(r => Object.keys(r.lin).filter(key => key.includes('*')).flatMap(key => key.split('*'))))];
+        const factors = [...new Set(rows.flatMap(r => Object.keys(r.lin).filter(isMonomial).flatMap(factorsOf)))];
         const fresh = (lin) => !path.has(canon(lin)) && !path.has(canonFlip(lin));
         // Split a factor at zero, else two factors against each other (so (x - y)² >= 0 becomes a product of rows).
         const zero = factors.find(f => fresh({ [f]: 1 }));
@@ -283,6 +308,98 @@ function growPlain(goal, path, budget) {
         return no;
     return { tree: { split, yes: yes.tree, no: no.tree }, nodes: budget.nodes };
 }
+// A leaf's squares and products without those its derivation never reads (directly, or through a product that does),
+// the rest renumbered: the same derivation over the same rows, so a smaller certificate (and a smaller Lean term).
+function trimmed(n0, steps, pairs, squares) {
+    const used = new Set(steps.flatMap(st => (st.kind === 'input' && st.index >= n0 ? [st.index] : [])));
+    for (let j = pairs.length - 1; j >= 0; j--)
+        if (used.has(n0 + squares.length + j))
+            for (const i of pairs[j])
+                if (i >= n0)
+                    used.add(i);
+    const keepS = squares.flatMap((_, s) => (used.has(n0 + s) ? [s] : [])), keepP = pairs.flatMap((_, j) => (used.has(n0 + squares.length + j) ? [j] : []));
+    const to = new Map();
+    keepS.forEach((s, r) => to.set(n0 + s, n0 + r));
+    keepP.forEach((j, r) => to.set(n0 + squares.length + j, n0 + keepS.length + r));
+    const re = (i) => (i < n0 ? i : to.get(i));
+    return {
+        steps: steps.map(st => (st.kind === 'input' ? { ...st, index: re(st.index) } : st)),
+        products: keepP.map(j => [re(pairs[j][0]), re(pairs[j][1])]),
+        squares: keepS.map(s => squares[s]),
+    };
+}
+// The difference of each product's two factors in the goal's hypotheses, as the path reads them (a factor with an open
+// choice in it is left out: a product of one isn't a monomial).
+const productMemo = new WeakMap();
+function productForms(goal, path) {
+    let prods = productMemo.get(goal);
+    if (!prods) {
+        const found = [], seen = new WeakSet();
+        const walk = (t) => {
+            if (seen.has(t))
+                return;
+            seen.add(t);
+            if (t.op === 'prod')
+                found.push(t);
+            for (const val of Object.values(t))
+                if (Array.isArray(val))
+                    val.forEach(x => walk(x));
+                else if (typeof val === 'object' && val !== null)
+                    walk(val);
+        };
+        goal.hyps.forEach(walk);
+        productMemo.set(goal, (prods = found));
+    }
+    const out = [];
+    for (const e of prods) {
+        if (e.op !== 'prod')
+            continue;
+        const a = linear(e.a, path), b = linear(e.b, path);
+        if (!a || !b)
+            continue;
+        const t = sub(a, b);
+        if (Object.keys(t).some(key => key.includes('⟦')) || Object.entries(t).every(([key, c]) => key === '1' || c === 0))
+            continue;
+        out.push(Object.fromEntries(Object.entries(t).filter(([, c]) => c !== 0)));
+    }
+    return out;
+}
+// The forms whose squares a leaf may try: for each monomial, (u − w) for every way to split its factors (all of them,
+// or all but one when there is an odd number) into two halves u and w that differ (u = w is a square already, a
+// natural monomial). At most 64, from the smallest monomials up.
+function squareForms(rows) {
+    const monos = [...new Set(rows.flatMap(r => Object.keys(r.lin).filter(isMonomial)))].sort((a, b) => factorsOf(a).length - factorsOf(b).length);
+    const out = new Map();
+    const name = (fs) => [...fs].sort().join('*');
+    const halves = (fs) => {
+        const pick = (from, chosen) => {
+            if (chosen.length === fs.length / 2) {
+                const u = name(chosen.map(i => fs[i])), w = name(fs.filter((_, i) => !chosen.includes(i)));
+                if (u < w) {
+                    const t = { [u]: 1, [w]: -1 };
+                    out.set(canon(t), t);
+                }
+                return;
+            }
+            for (let i = from; i < fs.length; i++)
+                pick(i + 1, [...chosen, i]);
+        };
+        pick(0, []);
+    };
+    for (const m of monos) {
+        const fs = factorsOf(m);
+        if (fs.length > 6)
+            continue;
+        if (fs.length % 2 === 0)
+            halves(fs);
+        else
+            for (let i = 0; i < fs.length; i++)
+                halves(fs.filter((_, j) => j !== i));
+        if (out.size >= 64)
+            break;
+    }
+    return [...out.values()].slice(0, 64);
+}
 // A tree found under one more decision (`from`, the path with it) as a tree under the path without it (`to`), if no
 // leaf reads the decision: each leaf's rows found again among the rows the shorter path gives (the same rows, renumbered:
 // the decision's own row, and any row only it makes, are not there), every split kept. The derivations are the same
@@ -324,7 +441,7 @@ function lift(goal, tree, from, to) {
                 return undefined;
             products.push([pi, pj]);
         }
-        return { leaf, ...(t.products ? { products } : {}) };
+        return { leaf, ...(t.products ? { products } : {}), ...(t.squares ? { squares: t.squares } : {}) };
     };
     return go(tree, from, to);
 }
@@ -475,7 +592,7 @@ function bisect(rows, path) {
 // Branch and bound for unbounded systems: split on a variable the rational solution puts between two integers.
 function fractional(point, path) {
     for (const [x, value] of Object.entries(point ?? {})) {
-        if (Math.abs(value - Math.round(value)) < 1e-9 || x.includes('*'))
+        if (Math.abs(value - Math.round(value)) < 1e-9 || isMonomial(x))
             continue;
         const c = Math.floor(value), lin = c === 0 ? { [x]: 1 } : { [x]: 1, 1: -c };
         if (!path.has(canon(lin)) && !path.has(canonFlip(lin)))
@@ -790,6 +907,26 @@ export function proveLaws(m, laws) {
         return { proven: false, nodes: 0, leaves: 0, failed: { goal: 'witnesses', stuck: out.stuck }, checked: false };
     return { ...proveLawsAsGiven(m, out.items), laws: out.items };
 }
+// One law's two goals, every law assumed (core/infer.ts adds laws one at a time and reproves only what isn't proven
+// yet); not a proof of the set, which proveLaws gives. Laws with some key go through proveLaws.
+export function proveLaw(m, laws, i) {
+    const law = laws[i];
+    if (laws.some(l => someKeys(l.holds).length)) {
+        const r = proveLaws(m, laws);
+        return r.proven ? { proven: true } : { proven: false, goal: r.failed.goal, stuck: r.failed.stuck, ...(r.failed.witness ? { witness: r.failed.witness } : {}) };
+    }
+    const keys = [...readKeys(m, laws), ...witnesses(m)];
+    const inst = instancesFor(m, laws, inst => obligations(m, laws, { [law.name]: inst }, i), {
+        seed: [...keys, ...(law.forall ? [{ op: 'var', name: `${law.forall}#` }] : []), ...(law.keys ?? []).map((name) => ({ op: 'var', name }))],
+        focus: [...(law.forall ? [`${law.forall}#`] : []), ...(law.keys ?? [])],
+    });
+    for (const goal of obligations(m, laws, { [law.name]: inst }, i)) {
+        const out = grow(goal);
+        if (!('tree' in out))
+            return { proven: false, goal: goal.name, stuck: out.stuck, ...(out.witness ? { witness: out.witness } : {}) };
+    }
+    return { proven: true };
+}
 function proveLawsAsGiven(m, laws) {
     // Each law's two goals (start and step) get their own instances, seeded with its own keys.
     const keys = [...readKeys(m, laws), ...witnesses(m)], instances = {};

package/dist/lean-kernel/emit.d.ts

@@ -1,5 +1,5 @@
 import type { C, E, Law, Machine, Recurrence } from '../core/machine.js';
-import { type Step } from '../core/solver.js';
+import { type Lin, type Step } from '../core/solver.js';
 import { type Fold, type Goal, type Instances, type Liveness, type Loop, type Path, type StepLaw, type Tree } from '../kernel/kernel.js';
 import { leanLibrary } from './library.js';
 export { leanLibrary };
@@ -13,6 +13,7 @@ export declare const list: (xs: string[]) => string;
 export declare function leaves(t: Tree, path: Path, visit: (t: Tree & {
     leaf: Step[];
     products?: [number, number][];
+    squares?: Lin[];
 }, path: Path) => void): void;
 export declare function encode(ex: Exported, tamper?: boolean, dropStep?: boolean, globalVars?: string[], globalMaps?: string[]): {
     tab: string;

package/dist/lean-kernel/emit.js

@@ -1,6 +1,6 @@
 import { atMost, n, not, pointWrite } from "../core/machine.js";
 import { add, k, scale, sub } from "../core/solver.js";
-import { boundOf, canon, columnTerm, stateName, termColumn, historyMachine, foldObligations, leafConstraints, loopLiveness, loopMachine, linear, livenessHelpful, livenessParts, livenessRanks, loopObligations, trueC, obligations, progressObligations, stepLawObligations, substC, witnessesOf, withProducts } from "../kernel/kernel.js";
+import { boundOf, canon, factorsOf, isCell, isMonomial, columnTerm, stateName, termColumn, historyMachine, foldObligations, leafConstraints, loopLiveness, loopMachine, linear, livenessHelpful, livenessParts, livenessRanks, loopObligations, trueC, obligations, progressObligations, stepLawObligations, substC, witnessesOf, withProducts } from "../kernel/kernel.js";
 import { grow, proveBuilt, proveLaws, proveStepLaws } from "../kernel/prove.js";
 import { refinement, refinementSides } from "../core/compose.js";
 import { leanSurface, leanTerms } from "./lean-terms.js";
@@ -53,14 +53,20 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
     // shallower cells first so a key reads only earlier columns.
     const vars = globalVars ?? [...new Set(goal.hyps.flatMap(varsOf))];
     const cells = new Set(), terms = new Set();
+    // Monomials: every one a leaf's rows or products use, or that a product term has under the leaf's path, with the
+    // cells among their factors.
+    const monos = new Set();
+    const addMono = (name) => { monos.add(name); for (const f of factorsOf(name))
+        if (isCell(f))
+            addCell(f); };
     const addCell = (name) => { if (cells.has(name))
         return; cells.add(name); for (const key of Object.keys(cellKey(name)))
-        if (key.includes('['))
+        if (isMonomial(key))
+            addMono(key);
+        else if (key.includes('['))
             addCell(key);
         else if (key.startsWith('⟦'))
             terms.add(key); };
-    // Monomials: every one a leaf's rows or products use, or that a product term has under the leaf's path.
-    const monos = new Set();
     const subterms = (c) => {
         const out2 = [];
         const we = (e) => { out2.push(e); if (e.op === 'if') {
@@ -96,14 +102,14 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
     };
     goal.hyps.forEach(choices);
     leaves(tree, new Map(), (leaf, path) => {
-        for (const r of withProducts(leafConstraints(goal, path), leaf.products ?? []))
+        for (const r of [...withProducts(leafConstraints(goal, path), leaf.products ?? [], leaf.squares), ...(leaf.squares ?? []).map(lin => ({ lin }))])
             for (const key of Object.keys(r.lin)) {
-                if (key.includes('['))
+                if (isMonomial(key))
+                    addMono(key);
+                else if (key.includes('['))
                     addCell(key);
                 else if (key.startsWith('⟦'))
                     terms.add(key);
-                else if (key.includes('*'))
-                    monos.add(key);
             }
         // Each cell a hypothesis reads under the path, kept or not: two reads of one cell cancel in a row (T − T), yet
         // Lean's linear form of each still needs the cell's column to see the comparison decided.
@@ -111,18 +117,25 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
             for (const e of subterms(h)) {
                 if (e.op === 'prod')
                     for (const key of Object.keys(linear(e, path) ?? {}))
-                        if (key.includes('*'))
-                            monos.add(key);
+                        if (isMonomial(key))
+                            addMono(key);
                 if (e.op === 'get')
                     for (const key of Object.keys(linear(e, path) ?? {}))
-                        if (key.includes('['))
+                        if (isCell(key))
                             addCell(key);
             }
     });
     const depth = (name) => name.split('[').length;
-    // Term columns (open choices, each standing for its term's value) before the cells, whose keys may read them.
-    const cols = [...vars, ...[...monos].sort((a, b) => a.split('*').length - b.split('*').length), ...[...terms].sort((a, b) => Number(a.slice(1, -1)) - Number(b.slice(1, -1))), ...[...cells].sort((a, b) => depth(a) - depth(b))];
+    // Term columns (open choices, each standing for its term's value) before the cells, whose keys may read them; a
+    // monomial with a cell among its factors after the cells.
+    const degree = (a, b) => factorsOf(a).length - factorsOf(b).length;
+    const plainMonos = [...monos].filter(m => factorsOf(m).every(f => !isCell(f))).sort(degree), cellMonos = [...monos].filter(m => factorsOf(m).some(isCell)).sort(degree);
+    const cols = [...vars, ...plainMonos, ...[...terms].sort((a, b) => Number(a.slice(1, -1)) - Number(b.slice(1, -1))), ...[...cells].sort((a, b) => depth(a) - depth(b)), ...cellMonos];
     const col = new Map(cols.map((name, j) => [name, j]));
+    for (const cell of cells)
+        for (const key of Object.keys(cellKey(cell)))
+            if (cellMonos.includes(key))
+                throw new Error(`${ex.name}: the key of ${cell} reads a product of cells`);
     const maps = globalMaps ?? [...new Set([...[...cells].map(cellMap), ...goal.hyps.flatMap(h => [...JSON.stringify(h).matchAll(/"op":"get","map":"([^"]+)"/g)].map(m => m[1]))])];
     const dense = (lin) => {
         const coefs = new Array(cols.length).fill(0);
@@ -141,10 +154,10 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
     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);
-    const tab = cols.map(name => (name.includes('[') ? `.cell ${maps.indexOf(cellMap(name))} ${row(cellKey(name))}`
-        : name.startsWith('⟦') ? `.term (${e(columnTerm(name))})`
-            : name.includes('*') ? `.mono ${list(name.split('*').map(f => { const j = vars.indexOf(f); if (j < 0)
-                throw new Error(`${ex.name}: factor ${f}`); return j; }).sort((a, b) => a - b).map(String))}`
+    const tab = cols.map(name => (isMonomial(name) ? `.mono ${list(factorsOf(name).map(f => { const j = col.get(f); if (j === undefined)
+        throw new Error(`${ex.name}: factor ${f}`); return j; }).sort((a, b) => a - b).map(String))}`
+        : name.includes('[') ? `.cell ${maps.indexOf(cellMap(name))} ${row(cellKey(name))}`
+            : name.startsWith('⟦') ? `.term (${e(columnTerm(name))})`
                 : `.var ${vars.indexOf(name)}`));
     let leafNo = 0;
     const lean = (t, path) => {
@@ -152,10 +165,10 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
             const id = canon(t.split);
             return `.split ${row(t.split)}\n  (${lean(t.yes, new Map(path).set(id, { lin: t.split, holds: true }))})\n  (${lean(t.no, new Map(path).set(id, { lin: t.split, holds: false }))})`;
         }
-        const base = leafConstraints(goal, path), prods = t.products ?? [];
-        const rows = withProducts(base, prods).map(r => r.lin), n0 = base.length;
-        // Only the rows the derivation and the products read, renumbered (products follow them, in order); cuts carry
-        // their quotient row (Cert's format).
+        const base = leafConstraints(goal, path), prods = t.products ?? [], squares = t.squares ?? [];
+        const rows = withProducts(base, prods, squares).map(r => r.lin), n0 = base.length;
+        // Only the rows the derivation and the products read, renumbered (the squares follow them, then the products, in
+        // order); cuts carry their quotient row (Cert's format).
         const used = [...new Set([...t.leaf.flatMap(s => (s.kind === 'input' && s.index < n0 ? [s.index] : [])), ...prods.flat().filter(i => i < n0)])].sort((a, b) => a - b);
         const at = new Map(used.map((old, j) => [old, j]));
         const idx = (i) => (i < n0 ? at.get(i) : used.length + i - n0);
@@ -179,7 +192,7 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
             steps = steps.slice(0, -1); // the first leaf loses its last step
         // Cell pairs the path proves equal (Lean re-checks each).
         const eqs = [], pairs = [];
-        const cellCols = cols.map((name, j) => ({ name, j })).filter(c2 => c2.name.includes('['));
+        const cellCols = cols.map((name, j) => ({ name, j })).filter(c2 => isCell(c2.name));
         for (const [a, p] of cellCols.entries())
             for (const q of cellCols.slice(a + 1)) {
                 if (cellMap(p.name) !== cellMap(q.name))
@@ -201,7 +214,8 @@ export function encode(ex, tamper = false, dropStep = true, globalVars, globalMa
             const j = 'pair' in src ? pairs.indexOf([...src.pair].sort().join('\n')) : col.get('nat' in src ? src.nat : src.term) ?? -1;
             return j < 0 ? '.any' : 'pair' in src ? `.eq ${j}` : 'nat' in src ? `.nat ${j}` : `.term ${j}`;
         };
-        return `.leafAt ${list(used.map(u => `(${row(rows[u])}, ${hint(base[u].src)})`))} ${list(steps)} ${list(eqs)} ${list(prods.map(([i, j]) => `(${idx(i)}, ${idx(j)})`))}`;
+        const at2 = list(used.map(u => `(${row(rows[u])}, ${hint(base[u].src)})`)), rest = `${list(steps)} ${list(eqs)} ${list(prods.map(([i, j]) => `(${idx(i)}, ${idx(j)})`))}`;
+        return squares.length ? `.leafSq ${at2} ${list(squares.map(row))} ${rest}` : `.leafAt ${at2} ${rest}`;
     };
     return { tab: list(tab), hyps: list(goal.hyps.map(c)), tree: lean(tree, new Map()), cols, c, e };
 }