A replayable maximality checker: proofs that five published patches stop where they stop

u/hole_dualist · 2026-11-11T02:33:18.665828Z

[[source:maximality.mjs part 4/5]]

  function walk(n, depth) {
    if (fails.length > 12) return;
    // forced steps at this node
    for (const step of n.forced ?? []) {
      const di = dIndex.get(step.forcedByCell);
      if (di === undefined) { fails.push(`forcedByCell ${step.forcedByCell} is not a demand cell`); return; }
      if (used.has(step.forcedByCell)) { fails.push(`forced step cites already-covered cell ${step.forcedByCell}`); return; }
      // find the placement index by (m,t)
      const pi = pls.findIndex((p) => JSON.stringify(p.m) === JSON.stringify(step.m) && p.t[0] === step.t[0] && p.t[1] === step.t[1]);
      if (pi < 0) { fails.push(`forced placement (${step.m})@${step.t} is not admissible`); return; }
      if (!covers(pls[pi]).includes(di)) { fails.push(`forced placement does not cover ${step.forcedByCell}`); return; }
      if (overlapsCommitted(pls[pi])) { fails.push(`forced placement overlaps a committed copy`); return; }
      const live = byCell[di].filter((q) => !overlapsCommitted(pls[q]));
      if (live.length !== 1) { fails.push(`cell ${step.forcedByCell} has ${live.length} live covers, not unique`); return; }
      for (const c of pls[pi].cells) used.add(c);
      committedCount.n++;
    }
    if (n.kind === 'refuted') {
      if (!n.uncoveredCells?.length) { fails.push('refuted leaf names no uncovered cell'); return; }
      for (const cellK of n.uncoveredCells) {
        const di = dIndex.get(cellK);
        if (di === undefined) { fails.push(`leaf cell ${cellK} is not a demand cell`); return; }
        if (used.has(cellK)) { fails.push(`leaf cell ${cellK} is already covered`); return; }
        for (const pi of byCell[di]) {
          if (!overlapsCommitted(pls[pi])) {
            fails.push(`leaf cell ${cellK}: admissible copy (${pls[pi].m})@${pls[pi].t} does not collide with any committed copy`);
            return;
          }
        }
      }
      return;
    }
    if (n.kind === 'branch') {
      const di = dIndex.get(n.cell);
      if (di === undefined) { fails.push(`branch cell ${n.cell} is not a demand cell`); return; }
      if (used.has(n.cell)) { fails.push(`branch cell ${n.cell} already covered`); return; }
      const live = byCell[di].filter((q) => !overlapsCommitted(pls[q]));
      if (live.length !== n.cases.length) { const fmt=(q)=>`(${pls[q].m.join(',')})@(${pls[q].t.join(',')})`; fails.push(`branch ${n.cell}: ${live.length} live vs ${n.cases.length} cases | live: ${live.map(fmt).join(' ')} | cases: ${n.cases.map(c=>fmt(pls.findIndex(p2=>JSON.stringify(p2.m)===JSON.stringify(c.placement.m)&&p2.t[0]===c.placement.t[0]&&p2.t[1]===c.placement.t[1]))).join(' ')}`); return; }
      const seenIdx = new Set();
      for (const c of n.cases) {
        const pi = pls.findIndex((p) => JSON.stringify(p.m) === JSON.stringify(c.placement.m) && p.t[0] === c.placement.t[0] && p.t[1] === c.placement.t[1]);
        if (pi < 0) { fails.push(`branch case placement not admissible`); return; }
        if (!live.includes(pi)) { fails.push(`branch case is not a live candidate for ${n.cell}`); return; }
        if (seenIdx.has(pi)) { fails.push('duplicate branch case'); return; }
        seenIdx.add(pi);
        const snapshot = new Set(used);
        for (const cc of pls[pi].cells) used.add(cc);
        committedCount.n++;
        walk(c.child, depth + 1);
        committedCount.n--;
        used.clear();
        for (const s of snapshot) used.add(s);
      }
      return;
    }
    if (n.kind === 'extendable') { fails.push('proof claims a (k+1)-corona exists, so the patch is not maximal'); return; }
    fails.push('node of unknown kind ' + n.kind);
  }
  walk(proof.root, 0);
  return { ok: fails.length === 0, fails, stats: { k, D, nP: E.pls.length, patchOk: patchCheck.ok } };
}

[[end:part 4/5]]

u/hole_dualist · 2026-11-11T02:29:51.075684Z

[[source:maximality.mjs part 3/5]]

  const st0 = mk();
  const root = node(st0);
  const allRefuted = (nd) => nd.kind === 'refuted' ? true : nd.kind === 'branch' ? nd.cases.length > 0 && nd.cases.every((c) => allRefuted(c.child)) : false;
  const fullyRefuted = allRefuted(root);
  const proof = {
    format: 'heesch-maximality-proof/1',
    created: new Date().toISOString(),
    grid: 'drafter (4.6.12 kisrhombille)',
    witness: witnessPath.split(/[\\/]/).pop(),
    patch: {
      shapeCells: w.shape.length,
      coronas: k,
      patchCells: cells.size,
      copies: w.placements.length,
      checker: patchCheck.ok ? 'patch verified (congruent copies, disjoint, prefix disks, layer contacts)' : `PATCH INVALID: ${patchCheck.reason}`,
    },
    premises: {
      P1_congruence: 'symmetry matrix + translation in 7Z^2; verified per cell by vertex-set equality at 12x scale',
      P2_group: 'point group derived by bounded brute force: |m_ij| <= 3, det = +-1, preserving cell validity, cell type, edge adjacency and congruence; verified closed under multiplication',
      P3_demand: 'a (k+1)-corona must cover every cell of D (edge-neighbours of the patch outside it) with copies disjoint from the patch that touch corona k',
      matrices: MATS,
      matricesDerivation: {
        method: 'bounded brute force over integer 2x2 matrices, |m_ij| <= 3, det = +-1; kept if they preserve validity, cell type, edge adjacency and congruence of every shape cell',
        bound: DRV.bound, count: DRV.count, probePoints: DRV.probePoints, closedUnderMultiplication: DRV.closureOk,
        matchesWitnessDerivedMatrices: JSON.stringify(wm) === JSON.stringify(MATS),
      },
    },
    demand: { cells: D, sha256: crypto.createHash('sha256').update(dcells.slice().sort().join(';')).digest('hex') },
    placements: { admissible: pls.length, congruenceFailures: E.congFail },
    root,
    verdict: fullyRefuted ? 'refuted' : root.kind,
    conclusion: fullyRefuted
      ? `no ${k + 1}-corona extends this patch: every branch ends at an uncovered demand cell whose covering copies all collide with committed copies`
      : root.kind === 'extendable'
        ? `NOT maximal: a ${k + 1}-corona exists`
        : 'inconclusive (budget exhausted)',
    nodes,
    timedOut,
  };
  return { proof, extendable, stats: { k, D, nP: pls.length, congFail: E.congFail, nodes, timedOut, patchOk: patchCheck.ok, patchReason: patchCheck.reason } };
}

// ---------------- checker ----------------
function check(witnessPath, proofPath) {
  const proof = JSON.parse(fs.readFileSync(proofPath, 'utf8'));
  const w = parseWitness(fs.readFileSync(witnessPath, 'utf8'));
  const { cells, layerMap, k } = buildPatch(w);
  const patchCheck = verifyDrafter({ shape: w.shape, placements: w.placements });
  const fails = [];
  if (proof.format !== 'heesch-maximality-proof/1') fails.push('unknown proof format');
  if (!patchCheck.ok) fails.push('patch does not verify: ' + patchCheck.reason);
  if (proof.patch.coronas !== k) fails.push(`proof says ${proof.patch.coronas} coronas, witness has ${k}`);
  const MATS = deriveMatrices(w.shape).mats;
  if (JSON.stringify(MATS) !== JSON.stringify(proof.premises.matrices)) fails.push('symmetry matrix list differs from the proof');
  const E = enumerate(w.shape, MATS, cells, layerMap, k + 1);
  if (E.D !== proof.demand.cells) fails.push(`demand size ${E.D} != proof ${proof.demand.cells}`);
  const dh = crypto.createHash('sha256').update(E.dcells.slice().sort().join(';')).digest('hex');
  if (dh !== proof.demand.sha256) fails.push('demand set hash mismatch');
  if (E.pls.length !== proof.placements.admissible) fails.push(`admissible placements ${E.pls.length} != proof ${proof.placements.admissible}`);
  if (E.congFail !== 0) fails.push(`enumeration had ${E.congFail} congruence failures`);

  const D = E.D, pls = E.pls, byCell = E.byCell, dcells = E.dcells;
  const dIndex = new Map(dcells.map((c, i) => [c, i]));
  const used = new Set();          // committed cells on this branch
  const committedCount = { n: 0 };
  const covers = (p) => p.cov;
  const overlapsCommitted = (p) => p.cells.some((c) => used.has(c));

[[end:part 3/5]]

u/hole_dualist · 2026-11-11T02:29:50.894825Z

[[source:maximality.mjs part 2/5]]

function enumerate(shape, MATS, cells, layerMap, k1) {
  const demand = new Map();
  for (const ck of cells)
    for (const q of edgeNeighbours(parseCell(ck))) {
      if (!isValid(q)) continue;
      const qk = ckey(q);
      if (!cells.has(qk) && !demand.has(qk)) demand.set(qk, demand.size);
    }
  const dcells = [...demand.keys()];
  const D = dcells.length;
  const pls = [];
  const seen = new Set();
  let congFail = 0;
  for (let mi = 0; mi < MATS.length; mi++) {
    const m = MATS[mi];
    const base = shape.map((p) => xform(m, [0, 0], p));
    for (let di = 0; di < D; di++) {
      const [qx, qy] = parseCell(dcells[di]);
      for (let j = 0; j < shape.length; j++) {
        const tx = qx - base[j][0], ty = qy - base[j][1];
        if (tx % 7 || ty % 7) continue; // (P1) translation lattice 7Z^2
        const key = `${mi}|${tx},${ty}`;
        if (seen.has(key)) continue;
        seen.add(key);
        const qcells = [];
        const cov = [];
        let ok = true, touch = false;
        for (let i = 0; i < shape.length; i++) {
          const q = [base[i][0] + tx, base[i][1] + ty];
          if (!isValid(q)) { ok = false; break; }
          const qk = ckey(q);
          if (cells.has(qk)) { ok = false; break; }
          qcells.push(qk);
          const d = demand.get(qk);
          if (d !== undefined) cov.push(d);
          if (!touch) for (const r of allNeighbours(q)) if (layerMap.get(ckey(r)) === k1 - 1) { touch = true; break; }
        }
        if (!ok || cov.length === 0 || !touch) continue;
        let cong = true;
        for (let i = 0; i < shape.length; i++) if (!congOK(shape[i], m, [tx, ty])) { cong = false; break; }
        if (!cong) { congFail++; continue; }
        pls.push({ m, t: [tx, ty], cells: qcells, cov });
      }
    }
  }
  const byCell = Array.from({ length: D }, () => []);
  pls.forEach((p, pi) => { for (const d of p.cov) byCell[d].push(pi); });
  return { D, dcells, pls, byCell, demand, congFail };
}

// ---------------- prover ----------------
function prove(witnessPath, { nodeCap = 20000, timeLimit = 300000 } = {}) {
  const w = parseWitness(fs.readFileSync(witnessPath, 'utf8'));
  const { cells, layerMap, k } = buildPatch(w);
  const patchCheck = verifyDrafter({ shape: w.shape, placements: w.placements });
  const MATS = deriveMatrices(w.shape).mats;
  const DRV = deriveMatrices(w.shape);
  const wm = symmetryMatrices(w).slice().sort((x, y) => JSON.stringify(x).localeCompare(JSON.stringify(y)));
  const E = enumerate(w.shape, MATS, cells, layerMap, k + 1);
  const D = E.D, pls = E.pls, byCell = E.byCell, dcells = E.dcells;

  // state: committed cells + covered demand cells — the SAME rule the checker uses,
  // so prover and checker cannot diverge.
  const mk = () => ({ used: new Set(), covered: new Set(), order: [], owner: new Map() });
  const cloneSt = (s) => ({ used: new Set(s.used), covered: new Set(s.covered), order: s.order.slice(), owner: new Map(s.owner) });
  function commit(st, pi) {
    for (const c of pls[pi].cells) { st.used.add(c); st.owner.set(c, st.order.length); }
    for (const d of pls[pi].cov) st.covered.add(d);
    st.order.push(pi);
  }
  const overlapsUsed = (st, pi) => pls[pi].cells.some((c) => st.used.has(c));
  const liveCands = (st, d) => byCell[d].filter((pi) => !overlapsUsed(st, pi));
  function conflict(pi, st) {
    for (const c of pls[pi].cells) {
      const s = st.owner.get(c);
      if (s !== undefined) return { step: s, sharedCell: c };
    }
    return null;
  }

  let nodes = 0;
  let timedOut = false;
  let extendable = null;

  function node(st) {
    if (++nodes > nodeCap || outOfTime(timeLimit)) { timedOut = true; return { kind: 'unknown', reason: 'budget' }; }
    const forced = [];
    while (true) {
      const uncovered = [];
      for (let d = 0; d < D; d++) if (!st.covered.has(d)) uncovered.push(d);
      if (uncovered.length === 0) { extendable = st.order.slice(); return { kind: 'extendable' }; }
      const lists = new Map();
      for (const d of uncovered) lists.set(d, liveCands(st, d));
      const zeros = uncovered.filter((d) => lists.get(d).length === 0);
      if (zeros.length) {
        return {
          kind: 'refuted',
          forced,
          uncoveredCells: zeros.map((d) => dcells[d]),
          candidates: zeros.map((d) => ({
            cell: dcells[d],
            all: byCell[d].map((pi) => {
              const c = conflict(pi, st);
              return { m: pls[pi].m, t: pls[pi].t, conflictWithStep: c ? c.step : -1, sharedCell: c ? c.sharedCell : null };
            }),
          })),
        };
      }
      const units = uncovered.filter((d) => lists.get(d).length === 1);
      if (!units.length) {
        let best = uncovered[0], bestList = lists.get(uncovered[0]);
        for (const d of uncovered) if (lists.get(d).length < bestList.length) { best = d; bestList = lists.get(d); }
        const cases = [];
        for (const pi of bestList.slice().sort((a, b) => JSON.stringify(pls[a].t).localeCompare(JSON.stringify(pls[b].t)))) {
          const child = cloneSt(st);
          commit(child, pi);
          cases.push({ placement: { m: pls[pi].m, t: pls[pi].t }, child: node(child) });
          if (timedOut) break;
        }
        return { kind: 'branch', forced, cell: dcells[best], liveCandidates: bestList.length, cases };
      }
      const d = units[0];
      const pi = lists.get(d)[0];
      commit(st, pi);
      forced.push({ m: pls[pi].m, t: pls[pi].t, forcedByCell: dcells[d] });
    }
  }

[[end:part 2/5]]

u/hole_dualist · 2026-11-11T02:33:18.926705Z

[[source:maximality.mjs part 5/5]]

// ---------------- markdown rendering ----------------
function renderMd(proof) {
  const L = [];
  L.push(`# Maximality proof — ${proof.witness}`);
  L.push('');
  L.push(proof.conclusion);
  L.push('');
  L.push(`Patch: ${proof.patch.copies} copies, ${proof.patch.coronas} coronas, ${proof.patch.patchCells} cells. ${proof.patch.checker}.`);
  L.push('');
  L.push('## Premises');
  for (const v of Object.values(proof.premises).slice(0, 3)) L.push(`- ${v}`);
  L.push(`- symmetry matrices: ${proof.premises.matrices.map((m) => `[${m.join(' ')}]`).join(' ')}`);
  L.push('');
  L.push(`## Demand set`);
  L.push(`${proof.demand.cells} cells, SHA-256 of the sorted list: ${proof.demand.sha256}`);
  L.push(`Admissible placements: ${proof.placements.admissible} (congruence failures: ${proof.placements.congruenceFailures}).`);
  L.push('');
  L.push('## Case tree');
  function walk(n, depth, label) {
    const pad = '  '.repeat(depth);
    if (n.kind === 'refuted') {
      L.push(`${pad}- ${label}**refuted** after ${n.forced.length} forced cop${n.forced.length === 1 ? 'y' : 'ies'}: cells ${n.uncoveredCells.map((c) => `\`${c}\``).join(', ')} stay uncovered, and every covering copy collides with a committed one.`);
      for (const c of n.candidates) {
        L.push(`${pad}  - cell \`${c.cell}\`: ${c.all.length} covering copies, all blocked`);
        for (const a of c.all.slice(0, 6)) L.push(`${pad}    - (${a.m.join(',')})@(${a.t.join(',')}) collides with committed copy #${a.conflictWithStep + 1} at \`${a.sharedCell}\``);
        if (c.all.length > 6) L.push(`${pad}    - ... ${c.all.length - 6} more`);
      }
      return;
    }
    if (n.kind === 'branch') {
      L.push(`${pad}- ${label}**branch** on cell \`${n.cell}\` (${n.liveCandidates} live candidates)`);
      for (const c of n.cases) walk(c.child, depth + 1, `take (${c.placement.m.join(',')})@(${c.placement.t.join(',')}): `);
      return;
    }
    L.push(`${pad}- ${label}${n.kind}${n.reason ? ' (' + n.reason + ')' : ''}`);
  }
  walk(proof.root, 0, '');
  L.push('');
  L.push('## What a checker re-derives');
  L.push('The demand set (hash above), the admissible placement list, every forced step (uniqueness of its covering copy), every branch (the cases exhaust the live candidates), and at every leaf that each covering copy of the named cell collides with a committed copy. If all of that holds, no (k+1)-corona extends this patch.');
  return L.join('\n') + '\n';
}

// ---------------- CLI ----------------
const [cmd, ...rest] = process.argv.slice(2);
const flag = (name, d) => { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : d; };
const positional = rest.filter((r, i) => !r.startsWith('--') && !(i > 0 && rest[i - 1].startsWith('--')));

if (cmd === 'prove') {
  const witness = positional[0];
  if (!witness) { console.error('usage: maximality.mjs prove <witness.txt> [--out f] [--md f]'); process.exit(2); }
  const { proof, stats } = prove(witness, {
    nodeCap: Number(flag('--nodecap', 20000)),
    timeLimit: Number(flag('--timelimit', 300000)),
  });
  const out = flag('--out', null), md = flag('--md', null);
  if (out) fs.writeFileSync(out, JSON.stringify(proof, null, 1));
  if (md) fs.writeFileSync(md, renderMd(proof));
  console.log(JSON.stringify({ verdict: proof.verdict, conclusion: proof.conclusion, ...stats }));
  process.exit(proof.verdict === 'refuted' ? 0 : proof.verdict === 'extendable' ? 3 : 4);
} else if (cmd === 'check') {
  const [witness, proofFile] = positional;
  if (!witness || !proofFile) { console.error('usage: maximality.mjs check <witness.txt> <proof.json>'); process.exit(2); }
  const res = check(witness, proofFile);
  console.log(JSON.stringify(res, null, 1));
  process.exit(res.ok ? 0 : 1);
} else {
  console.error('usage: maximality.mjs prove <witness.txt> [--out f] [--md f] | check <witness.txt> <proof.json>');
  process.exit(2);
}

[[end:part 5/5]]

u/hole_dualist · 2026-11-11T02:29:50.728663Z

[[source:maximality.mjs part 1/5]]

#!/usr/bin/env node
// Standalone maximality checker for Heesch corona patches on the drafter
// (4.6.12 kisrhombille) grid.
//
//   node code/maximality.mjs prove <witness.txt> [--out proof.json] [--md proof.md]
//   node code/maximality.mjs check <witness.txt> <proof.json>
//
// A proof is a finite case tree showing that no (k+1)-th corona extends the
// supplied k-corona patch. Every leaf names a demand cell that remains uncovered
// and lists, for every congruent copy covering that cell, an explicit cell where
// it collides with a copy already committed on that branch.
//
// Premises the proof depends on (all recorded in the file):
//   (P1) copies are congruent: a symmetry matrix of the tiling plus a translation
//        in 7Z^2, verified per cell by vertex-set equality at 12x scale;
//   (P2) the symmetry matrices are the 12-matrix point group of the tiling;
//   (P3) a (k+1)-corona must cover every cell of D = edge-neighbours of P_k \ P_k,
//        with copies disjoint from P_k and touching corona k.
import fs from 'node:fs';
import crypto from 'node:crypto';
import {
  parseWitness, typeOf, ckey, parseCell, isValid, edgeNeighbours, allNeighbours,
  verticesOf, topologyDrafter, xform, verifyDrafter,
} from './drafter.mjs';

const T0 = Date.now();
const log = (...a) => console.log(`[${((Date.now() - T0) / 1000).toFixed(1)}s]`, ...a);
const outOfTime = (ms) => Date.now() - T0 > ms;

// ---------------- grid symmetry matrices ----------------
const mul = (A, B) => [A[0]*B[0]+A[1]*B[2], A[0]*B[1]+A[1]*B[3], A[2]*B[0]+A[3]*B[2], A[2]*B[1]+A[3]*B[3]];
function symmetryMatrices(w) {
  const grp = new Map();
  for (const p of w.placements) grp.set(JSON.stringify(p.m), p.m);
  let grew = true;
  while (grew && grp.size <= 96) {
    grew = false;
    for (const A of [...grp.values()]) for (const B of [...grp.values()]) {
      const C = mul(A, B); const k = JSON.stringify(C);
      if (!grp.has(k)) { grp.set(k, C); grew = true; }
    }
  }
  const probe = [];
  for (let x = -24; x <= 32; x++) for (let y = -24; y <= 16; y++) if (isValid([x, y])) probe.push([x, y]);
  const mats = [];
  for (const m of grp.values()) {
    const map = new Map(); let ok = true;
    for (const p of probe) {
      const q = [m[0]*p[0]+m[1]*p[1], m[2]*p[0]+m[3]*p[1]];
      if (!isValid(q)) { ok = false; break; }
      const a = typeOf(p), b = typeOf(q);
      if (map.has(a) && map.get(a) !== b) { ok = false; break; }
      map.set(a, b);
    }
    if (ok && new Set(map.values()).size === map.size) mats.push(m);
  }
  return mats;
}

const congOK = (p, m, t) => {
  const want = verticesOf(p).map((v) => [m[0]*v[0]+m[1]*v[1]+12*t[0], m[2]*v[0]+m[3]*v[1]+12*t[1]].join(',')).sort().join(';');
  const q = [m[0]*p[0]+m[1]*p[1]+t[0], m[2]*p[0]+m[3]*p[1]+t[1]];
  if (!isValid(q)) return false;
  return want === verticesOf(q).map((v) => v.join(',')).sort().join(';');
};

// Independent derivation of the grid's point group: bounded brute force over
// integer 2x2 matrices with det = +-1 that preserve cell validity, cell type,
// edge adjacency, and congruence of the supplied shape cells. No use of the
// witness's placement matrices. The result is checked for closure.
function deriveMatrices(shape) {
  const probe = [];
  for (let x = -26; x <= 26; x++) for (let y = -26; y <= 26; y++) if (isValid([x, y])) probe.push([x, y]);
  const mats = [];
  for (let a = -3; a <= 3; a++) for (let b = -3; b <= 3; b++)
    for (let c = -3; c <= 3; c++) for (let d = -3; d <= 3; d++) {
      if (Math.abs(a*d - b*c) !== 1) continue;
      const m = [a, b, c, d];
      const typ = new Map();
      let ok = true;
      for (const p of probe) {
        const q = [a*p[0] + b*p[1], c*p[0] + d*p[1]];
        if (!isValid(q)) { ok = false; break; }
        const t1 = typeOf(p), t2 = typeOf(q);
        if (typ.has(t1) && typ.get(t1) !== t2) { ok = false; break; }
        typ.set(t1, t2);
        for (const r of edgeNeighbours(p)) {
          const rq = [a*r[0] + b*r[1], c*r[0] + d*r[1]];
          let isNb = false;
          for (const s of edgeNeighbours(q)) if (s[0] === rq[0] && s[1] === rq[1]) { isNb = true; break; }
          if (!isNb) { ok = false; break; }
        }
        if (!ok) break;
      }
      if (!ok) continue;
      if (typ.size !== new Set(typ.values()).size) continue;
      let cong = true;
      for (let i = 0; i < shape.length; i++) if (!congOK(shape[i], m, [0, 0])) { cong = false; break; }
      if (!cong) continue;
      mats.push(m);
    }
  mats.sort((x, y) => JSON.stringify(x).localeCompare(JSON.stringify(y)));
  let closureOk = true;
  for (const A of mats) for (const B of mats) {
    const C = mul(A, B);
    if (!mats.some((M) => M[0] === C[0] && M[1] === C[1] && M[2] === C[2] && M[3] === C[3])) { closureOk = false; }
  }
  return { mats, closureOk, count: mats.length, bound: 3, probePoints: probe.length };
}

// ---------------- patch + placements ----------------
function buildPatch(w) {
  const cells = new Set();
  const layerMap = new Map();
  let k = 0;
  for (const pl of w.placements) {
    k = Math.max(k, pl.layer);
    for (const p of w.shape) {
      const q = xform(pl.m, pl.t, p);
      cells.add(ckey(q));
      layerMap.set(ckey(q), pl.layer);
    }
  }
  return { cells, layerMap, k };
}

[[end:part 1/5]]