@bramas/simulant-lean-gen 0.0.0-stage → 0.1.1

package/dist/component.js

@@ -0,0 +1,196 @@
+import { T, showType, typeEq } from "@bramas/simulant-lang/types";
+import { fail, ident, Translator } from "./translate.js";
+/** Enum types mentioned by a type. */
+export function enumsOf(t, out = new Map()) {
+    switch (t.k) {
+        case 'enum':
+            out.set(t.name, t.ctors);
+            break;
+        case 'option':
+        case 'list':
+        case 'multiset':
+            enumsOf(t.of, out);
+            break;
+        case 'record':
+            for (const f of t.fields)
+                enumsOf(f.type, out);
+            break;
+    }
+    return out;
+}
+export function enumsInExpr(e, out) {
+    if (!e)
+        return;
+    const visit = (x) => {
+        if (!x || typeof x !== 'object')
+            return;
+        if (Array.isArray(x)) {
+            x.forEach(visit);
+            return;
+        }
+        const o = x;
+        if (o.e === 'lit' || o.k)
+            enumsOf((o.e === 'lit' ? o.type : o), out);
+        for (const v of Object.values(o))
+            visit(v);
+    };
+    visit(e);
+}
+export function enumDecl(name, ctors) {
+    return `inductive ${ident(name)} where\n${ctors.map(c => `  | ${ident(c)}`).join('\n')}\nderiving DecidableEq, Repr, Inhabited\n`;
+}
+export function structDecl(name, params, fields, type) {
+    if (!fields.length)
+        return `structure ${name}${params} where\nderiving DecidableEq, Repr\n`;
+    return `structure ${name}${params} where\n${fields.map(f => `  ${ident(f.name)} : ${type(f.type)}`).join('\n')}\nderiving DecidableEq, Repr\n`;
+}
+/** The experiment parameters read directly by initial values (`site := param site`). */
+function inputsOf(c) {
+    const inputs = new Map();
+    const fields = [...(c.world ?? []), ...(c.agent ?? [])];
+    const visit = (x, expected) => {
+        if (!x || typeof x !== 'object')
+            return;
+        const o = x;
+        if (o.e === 'param') {
+            if (!expected)
+                fail(`${c.name}: the type of parameter ${o.name} is not known (use it directly as an initial value)`);
+            inputs.set(o.name, expected);
+            return;
+        }
+        for (const v of Object.values(o))
+            if (v && typeof v === 'object')
+                visit(v);
+    };
+    for (const f of fields) {
+        const init = c.init?.world?.[f.name] ?? c.init?.agent?.[f.name];
+        if (init?.e === 'param')
+            inputs.set(init.name, f.type);
+        else
+            visit(init);
+    }
+    return [...inputs].map(([name, type]) => ({ name, type })).sort((a, b) => a.name.localeCompare(b.name));
+}
+export function componentInfo(c, namespace) {
+    const enums = new Map();
+    for (const f of [...(c.params ?? []), ...(c.world ?? []), ...(c.agent ?? []), ...(c.actions ?? [])])
+        enumsOf(f.type, enums);
+    for (const e of [c.beforeLook, c.beforeMove, c.afterMove, ...Object.values(c.init?.world ?? {}), ...Object.values(c.init?.agent ?? {}),
+        ...(c.sensors ?? []).map(s => s.body)])
+        enumsInExpr(e, enums);
+    return {
+        name: c.name, namespace, inputs: inputsOf(c),
+        hasWorld: !!c.world?.length, hasFields: !!c.agent?.length,
+        enums: [...enums].map(([name, ctors]) => ({ name, ctors })).filter(e => e.name !== 'Move'),
+    };
+}
+/** The Lean module of a component. */
+export function generateComponent(c, namespace) {
+    const info = componentInfo(c, namespace);
+    const world = c.world ?? [];
+    const fields = c.agent ?? [];
+    const flags = c.flags ?? [];
+    const actions = c.actions ?? [];
+    const params = c.params ?? [];
+    const worldT = T.record(world);
+    const fieldsT = T.record(fields);
+    const enumNames = new Set(info.enums.map(e => e.name));
+    /** The part of the world the component owns. */
+    const own = world.length ? '(World σ.N)' : 'Unit';
+    const env = (node, N, k) => ({
+        node, agent: `Fin ${k}`, N, k, pub: 'σ.P',
+        typeName: t => {
+            if (t.k === 'enum' && enumNames.has(t.name))
+                return ident(t.name);
+            if (t.k === 'record' && typeEq(t, worldT))
+                return `World ${N}`;
+            if (t.k === 'record' && typeEq(t, fieldsT))
+                return `Fields ${N}`;
+            return fail(`${c.name}: no Lean name for ${showType(t)}`);
+        },
+        worldField: (C, f) => `(L.world.get ${C}.world).${ident(f)}`,
+        agentFlag: (a, f) => `(Flags.${ident(f)} ${a}.flags)`,
+        agentField: (a, f) => `(L.fields.get ${a}.fields).${ident(f)}`,
+        decisionAction: (d, a) => `(Actions.${ident(a)} ${d}.act)`,
+        param: name => ident(name),
+        paramType: name => info.inputs.find(i => i.name === name)?.type ?? fail(`unknown parameter ${name}`),
+        effect: (w, raise) => {
+            const worldCode = w.length ? `fun x => { x with ${w.map(([f, v]) => `${ident(f)} := ${v}`).join(', ')} }` : 'id';
+            const one = ([flag, r]) => {
+                const cond = r.pred ? `${r.pred} a` : `(${r.set}).contains a`;
+                return `(if ${cond} then (Flags.raise_${ident(flag)} : σ.F) else FlagSet.none)`;
+            };
+            const raiseCode = raise.length
+                ? raise.map(one).reduce((acc, x) => `FlagSet.merge ${acc} ${x}`)
+                : 'FlagSet.none';
+            return `({ world := ${worldCode}, raise := fun a => ${raiseCode} } : OwnEffect σ ${own})`;
+        },
+        ts: 'ts', ds: 'ds',
+        layout: { pub: T.pub, mem: T.unit, worldType: worldT, flags, agentFields: fields, actions },
+        defs: new Map((c.defs ?? []).map(d => [d.name, d])),
+        defName: n => ident(n),
+    });
+    const hookEnv = env('Fin σ.N', 'σ.N', 'σ.k');
+    const initEnv = env('Fin N', 'N', 'k');
+    const tr = new Translator(hookEnv);
+    const trInit = new Translator(initEnv);
+    const paramVars = params.map(p => [p.name, ident(p.name), p.type]);
+    const paramBinders = params.map(p => `(${ident(p.name)} : ${tr.type(p.type)})`).join(' ');
+    const inputBinders = info.inputs.map(p => `(${ident(p.name)} : ${trInit.type(p.type)})`).join(' ');
+    const out = [];
+    out.push(`import Simulant\n\n/-! Generated from the IR of component \`${c.name}\` by packages/lean-gen. Do not edit. -/\n\nset_option linter.unusedVariables false\n`);
+    out.push(`namespace ${namespace}\nopen Simulant\n`);
+    for (const e of info.enums)
+        out.push(enumDecl(e.name, e.ctors));
+    if (world.length)
+        out.push(structDecl('World', ' (N : Nat)', world, t => trInit.type(t)));
+    if (fields.length)
+        out.push(structDecl('Fields', ' (N : Nat)', fields, t => trInit.type(t)));
+    out.push(`/-- The flags declared by \`${c.name}\`, with the laws of a composition's flags. -/`);
+    if (flags.length) {
+        out.push(`class Flags (F : Type) [FlagSet F] where\n${flags.map(f => {
+            const n = ident(f.name);
+            return `  ${n} : F → Bool\n  raise_${n} : F\n  ${n}_raise : ${n} raise_${n} = true\n  ${n}_merge : ∀ a b : F, ${n} (FlagSet.merge a b) = (${n} a || ${n} b)\n  ${n}_none : ${n} (FlagSet.none : F) = false`;
+        }).join('\n')}\n`);
+    }
+    else {
+        out.push('class Flags (F : Type) [FlagSet F] where\n');
+    }
+    out.push(actions.length
+        ? `class Actions (A : Type) where\n${actions.map(a => `  ${ident(a.name)} : A → ${trInit.type(a.type)}`).join('\n')}\n`
+        : 'class Actions (A : Type) where\n');
+    out.push(`/-- What the composition gives the component: lenses on the state it owns. -/\nstructure Ctx (σ : Sig) where\n${[world.length ? '  world : Lens σ.W (World σ.N)' : '', fields.length ? '  fields : Lens σ.X (Fields σ.N)' : ''].filter(Boolean).join('\n')}\n`);
+    // Initial values
+    if (world.length) {
+        const binds = world.map(f => {
+            const r = trInit.root(c.init.world[f.name], paramVars);
+            return [f.name, r];
+        });
+        out.push(`def initWorld {N : Nat} [NeZero N] ${paramBinders} ${inputBinders} : ND (World N) := do\n${binds.map(([n, r]) => `  let ${ident(n)} ← ${trInit.nd(r)}`).join('\n')}\n  pure { ${world.map(f => `${ident(f.name)} := ${ident(f.name)}`).join(', ')} }\n`);
+    }
+    for (const f of fields) {
+        const r = trInit.root(c.init.agent[f.name], [['i', 'i', T.nat], ...paramVars]);
+        out.push(`def init_${ident(f.name)} {N : Nat} [NeZero N] ${paramBinders} ${inputBinders} (i : Nat) : ND (${trInit.type(f.type)}) :=\n  ${trInit.nd(r)}\n`);
+    }
+    out.push(`section\nvariable {σ : Sig} [FlagSet σ.F] [Flags σ.F] [Actions σ.A]\n`);
+    for (const s of c.sensors ?? []) {
+        const r = tr.root(s.body, [['C', 'C', T.config], ['me', 'me', T.agent], ['frame', 'frame', T.frame], ...paramVars], 'C');
+        out.push(`def sensor_${ident(s.name)} (L : Ctx σ) ${paramBinders} (ts : TState) (C : Config σ) (me : Fin σ.k) (frame : Bool) : ND (${tr.type(r.t)}) :=\n  ${tr.nd(r)}\n`);
+    }
+    const hook = (body, args) => {
+        if (!body)
+            return `fun ${args} => pure ⟨id, fun _ => FlagSet.none⟩`;
+        return `fun ${args} => ${tr.nd(tr.root(body, [['C', 'C', T.config], ...paramVars], 'C'))}`;
+    };
+    out.push(`/-- The hooks, on the part of the world the component owns. -/
+def hooks ${paramBinders} (L : Ctx σ) : Hooks σ ${own} where
+  beforeLook := ${hook(c.beforeLook, 'ts C')}
+  beforeMove := ${hook(c.beforeMove, 'ts C ds')}
+  afterMove := ${hook(c.afterMove, 'ts C')}
+
+def component ${paramBinders} (L : Ctx σ) : Component σ :=
+  (hooks ${params.map(p => ident(p.name)).join(' ')} L).toComponent ${world.length ? 'L.world' : '(Lens.unit σ.W)'}
+`);
+    out.push(`end\n\nend ${namespace}\n`);
+    return out.join('\n');
+}

package/dist/differential.js

@@ -0,0 +1,159 @@
+/**
+ * Differential test of the generated Lean model against the interpreter
+ * (plan, Section 5.3): on a small instance, the computable Lean round and
+ * the interpreter must give the same successors, and every witness of the
+ * interpreter must be a witness in Lean (replay of interpreter paths).
+ *
+ * The interpreter explores the instance with agents kept in index order
+ * (as in Lean) and without symmetry reduction; a generated Lean file then
+ * evaluates the round on each configuration and prints the successors.
+ */
+import { execFileSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolvePub } from "@bramas/simulant-lang/types";
+import { Explorer } from "@bramas/simulant-engine/explorer";
+import { System } from "@bramas/simulant-engine/system";
+import { canonicalSort } from "@bramas/simulant-engine/values";
+import { generateModel } from "./model.js";
+import { fail } from "./translate.js";
+/** Groups the composed fields by owning component, in component order. */
+function parts(lay, which) {
+    const owners = [];
+    for (const f of lay[which])
+        if (!owners.includes(f.owner))
+            owners.push(f.owner);
+    return owners.map(owner => ({ owner, fields: lay[which].filter(f => f.owner === owner) }));
+}
+/** A Lean term for a value, with anonymous constructors (the expected type is always known). */
+function term(v, t) {
+    switch (t.k) {
+        case 'unit': return '()';
+        case 'bool':
+        case 'frame':
+        case 'nat': return String(v);
+        case 'int': return `(${v} : Int)`;
+        case 'node': return `⟨${v}, by decide⟩`;
+        case 'move': return `Simulant.Move.${v}`;
+        case 'enum': return `.${v}`;
+        case 'option': return v === null ? 'none' : `(some ${term(v, t.of)})`;
+        case 'list':
+        case 'multiset': return `[${v.map(x => term(x, t.of)).join(', ')}]`;
+        case 'record': return `⟨${t.fields.map(f => term(v[f.name], f.type)).join(', ')}⟩`;
+        default: return fail(`no Lean term for values of type ${t.k}`);
+    }
+}
+let depth = 0;
+/** Lean code printing `code` (of type `t`) as JSON. */
+function json(code, t) {
+    switch (t.k) {
+        case 'unit': return '"null"';
+        case 'bool':
+        case 'frame':
+        case 'nat':
+        case 'int': return `(toString ${code})`;
+        case 'node': return `(toString ${code}.val)`;
+        case 'move':
+        case 'enum': return `("\\"" ++ reprStr ${code} ++ "\\"")`;
+        case 'option': {
+            const y = `y${depth++}`;
+            return `(match ${code} with | none => "null" | some ${y} => ${json(y, t.of)})`;
+        }
+        case 'list':
+        case 'multiset': {
+            const y = `y${depth++}`;
+            return `("[" ++ ",".intercalate (${code}.map (fun ${y} => ${json(y, t.of)})) ++ "]")`;
+        }
+        case 'record':
+            return `("{" ++ ${t.fields.map(f => `"\\"${f.name}\\":" ++ ${json(`(${code}).${f.name}`, f.type)}`).join(' ++ "," ++ ')} ++ "}")`
+                .replace('"{" ++  ++ "}"', '"{}"');
+        default: return fail(`no JSON printer for type ${t.k}`);
+    }
+}
+/** Back to interpreter values: enum names lose their Lean namespace, multisets are sorted. */
+function normalize(v, t) {
+    switch (t.k) {
+        case 'move':
+        case 'enum': return String(v).split('.').pop();
+        case 'option': return v === null ? null : normalize(v, t.of);
+        case 'list': return v.map((x) => normalize(x, t.of));
+        case 'multiset': return canonicalSort(t.of)(v.map((x) => normalize(x, t.of)));
+        case 'record': return Object.fromEntries(t.fields.map(f => [f.name, normalize(v[f.name], f.type)]));
+        case 'unit': return null;
+        default: return v;
+    }
+}
+/** `mutate` edits the generated Lean source: tests use it to check that differences are detected. */
+export function differential(exp, params, leanDir, maxStates = 40, mutate = x => x) {
+    const system = new System(exp, params, { sortAgents: false });
+    const explorer = new Explorer(system, { symmetry: false, maxStates });
+    explorer.run();
+    const configs = explorer.states.map(s => s.config);
+    const lay = system.lay;
+    const pub = lay.pub, mem = lay.mem;
+    const N = system.topo.size;
+    const k = configs[0]?.agents.length ?? 0;
+    const worldParts = parts(lay, 'world');
+    const fieldParts = parts(lay, 'agentFields');
+    const sig = `(sig ${N} ${k})`;
+    const agentTerm = (a) => `{ pos := ⟨${a.pos}, by decide⟩, flags := ⟨${lay.flags.map(f => String(!!a.f[f.name])).join(', ')}⟩, fields := ⟨${fieldParts.map(p => `⟨${p.fields.map(f => term(a.f[f.name], resolvePub(f.type, pub))).join(', ')}⟩`).join(', ')}⟩, pub := ${term(a.pub, pub)}, mem := ${term(a.mem, mem)} }`;
+    const configTerm = (C) => `({ agents := #v[${C.agents.map(agentTerm).join(', ')}], world := ⟨${worldParts.map(p => `⟨${p.fields.map(f => term(C.world[f.name], f.type)).join(', ')}⟩`).join(', ')}⟩ } : Config ${sig})`;
+    depth = 0;
+    const agentJson = `"{\\"pos\\":" ++ toString a.pos.val ++ ",\\"pub\\":" ++ ${json('a.pub', pub)} ++ ",\\"mem\\":" ++ ${json('a.mem', mem)} ++ ",\\"f\\":{" ++ ${[...lay.flags.map(f => `"\\"${f.name}\\":" ++ toString a.flags.${f.name}`),
+        ...fieldParts.flatMap(p => p.fields.map(f => `"\\"${f.name}\\":" ++ ${json(`a.fields.${p.owner}.${f.name}`, f.type)}`))].join(' ++ "," ++ ') || '""'} ++ "}}"`;
+    const worldJson = `"{" ++ ${worldParts.flatMap(p => p.fields.map(f => `"\\"${f.name}\\":" ++ ${json(`C.world.${p.owner}.${f.name}`, f.type)}`)).join(' ++ "," ++ ') || '""'} ++ "}"`;
+    const ns = 'DiffModel';
+    const lean = `${generateModel(exp, ns)}
+open Simulant ${ns}
+
+def jAgent (a : Agent ${sig}) : String := ${agentJson}
+def jConfig (C : Config ${sig}) : String :=
+  "{\\"agents\\":[" ++ ",".intercalate (C.agents.toList.map jAgent) ++ "],\\"world\\":" ++ (${worldJson}) ++ "}"
+def jWitness (w : Witness) : String := "[" ++ ",".intercalate (w.map fun (s, i) => "[\\"" ++ s ++ "\\"," ++ toString i ++ "]") ++ "]"
+
+def configs : List (Config ${sig}) := [
+  ${configs.map(configTerm).join(',\n  ')}]
+
+#eval show IO Unit from do
+  for C in configs do
+    let succ := (model ${N} ${k}).roundA act0 C
+    IO.println ("[" ++ ",".intercalate (succ.map fun (w, _, C') => "[" ++ jWitness w ++ "," ++ jConfig C' ++ "]") ++ "]")
+`;
+    const dir = join(leanDir, '.diff');
+    mkdirSync(dir, { recursive: true });
+    const file = join(dir, `${exp.name.replace(/\W+/g, '_')}.lean`);
+    writeFileSync(file, mutate(lean));
+    const out = execFileSync('lake', ['env', 'lean', file], { cwd: leanDir, encoding: 'utf8', maxBuffer: 1 << 28 });
+    const lines = out.split('\n').filter(l => l.startsWith('['));
+    if (lines.length !== configs.length)
+        fail(`Lean printed ${lines.length} lines for ${configs.length} configurations:\n${out.slice(0, 2000)}`);
+    const normConfig = (c) => ({
+        agents: c.agents.map((a) => ({
+            pos: a.pos, pub: normalize(a.pub, pub), mem: normalize(a.mem, mem),
+            f: Object.fromEntries([...lay.flags.map(f => [f.name, a.f[f.name]]),
+                ...lay.agentFields.map(f => [f.name, normalize(a.f[f.name], f.type)])]),
+        })),
+        world: normalize(c.world, lay.worldType),
+    });
+    const mismatches = [];
+    let successors = 0;
+    configs.forEach((C, i) => {
+        const lean = JSON.parse(lines[i])
+            .map(([w, c]) => ({ w: JSON.stringify(w), key: system.key(normConfig(c)) }));
+        const engine = system.successors(C).map(s => ({ w: JSON.stringify(s.witness.map(c => [c.site, c.index])), key: s.key }));
+        successors += engine.length;
+        const leanKeys = new Set(lean.map(x => x.key));
+        const engineKeys = new Set(engine.map(x => x.key));
+        for (const key of engineKeys)
+            if (!leanKeys.has(key))
+                mismatches.push(`state ${i}: successor ${key} only in the interpreter`);
+        for (const key of leanKeys)
+            if (!engineKeys.has(key))
+                mismatches.push(`state ${i}: successor ${key} only in Lean`);
+        for (const e of engine) {
+            if (!lean.some(l => l.key === e.key && l.w === e.w))
+                mismatches.push(`state ${i}: witness ${e.w} of ${e.key} is not a Lean witness`);
+        }
+    });
+    return { states: configs.length, successors, mismatches };
+}

package/dist/library.js

@@ -0,0 +1,30 @@
+/**
+ * Generates the component library (`lean/Simulant/Library/*.lean`) from the
+ * standard library's IR:  npx tsx packages/lean-gen/src/library.ts
+ */
+import { writeFileSync } from "node:fs";
+import { stdlibElaborator } from "@bramas/simulant-lang/elab/node";
+import { resolveComponent } from "@bramas/simulant-lang/standalone";
+import { generateComponent } from "./component.js";
+/**
+ * The library's components, from the `.sim` standard library. Their
+ * arguments do not matter: parameters stay symbolic.
+ */
+export const libraryComponents = (() => {
+    const elab = stdlibElaborator();
+    return ['Hazards.BlackHole .mayEmerge', 'Faults.CrashStop 1', 'Faults.CrashAtNode', 'Storage.Pebbles',
+        'Frames.PersistentReflection', 'Monitors.Visited'].map(e => resolveComponent(elab.evaluate(e)));
+})();
+export const libraryNamespace = (name) => `Simulant.Library.${name}`;
+export function generateLibrary(dir) {
+    const names = [];
+    for (const c of libraryComponents) {
+        writeFileSync(new URL(`Library/${c.name}.lean`, dir), generateComponent(c, libraryNamespace(c.name)));
+        names.push(c.name);
+    }
+    writeFileSync(new URL('Library.lean', dir), names.map(n => `import Simulant.Library.${n}\n`).join(''));
+    return names;
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    console.log(generateLibrary(new URL('../../../lean/Simulant/', import.meta.url)).join('\n'));
+}