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

package/src/component.ts

@@ -0,0 +1,195 @@
+/**
+ * Generates a component as a Lean module that is generic over the
+ * composition (plan, Section 5.1): the component sees its own world fields
+ * and agent fields through lenses (`Ctx`), its own flags through a class,
+ * and its own actions through a class. A model provides the instances. A
+ * lemma about the component then applies to every model that contains it.
+ */
+import type { Component, Expr, Field, Type } from '@bramas/simulant-lang/ir';
+import { T, showType, typeEq } from '@bramas/simulant-lang/types';
+import { fail, ident, Translator, type Env } from './translate';
+
+export type ComponentInfo = {
+  name: string;
+  namespace: string;
+  /** Experiment parameters read by the initial values, with their types. */
+  inputs: Field[];
+  hasWorld: boolean;
+  hasFields: boolean;
+  enums: { name: string; ctors: string[] }[];
+};
+
+/** Enum types mentioned by a type. */
+export function enumsOf(t: Type, out: Map<string, string[]> = new Map()): Map<string, string[]> {
+  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: Expr | undefined, out: Map<string, string[]>) {
+  if (!e) return;
+  const visit = (x: unknown): void => {
+    if (!x || typeof x !== 'object') return;
+    if (Array.isArray(x)) { x.forEach(visit); return; }
+    const o = x as Record<string, unknown>;
+    if (o.e === 'lit' || o.k) enumsOf((o.e === 'lit' ? o.type : o) as Type, out);
+    for (const v of Object.values(o)) visit(v);
+  };
+  visit(e);
+}
+
+export function enumDecl(name: string, ctors: string[]): string {
+  return `inductive ${ident(name)} where\n${ctors.map(c => `  | ${ident(c)}`).join('\n')}\nderiving DecidableEq, Repr, Inhabited\n`;
+}
+
+export function structDecl(name: string, params: string, fields: Field[], type: (t: Type) => string): string {
+  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: Component): Field[] {
+  const inputs = new Map<string, Type>();
+  const fields = [...(c.world ?? []), ...(c.agent ?? [])];
+  const visit = (x: unknown, expected?: Type): void => {
+    if (!x || typeof x !== 'object') return;
+    const o = x as Record<string, unknown>;
+    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 as string, 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: Component, namespace: string): ComponentInfo {
+  const enums = new Map<string, string[]>();
+  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: Component, namespace: string): string {
+  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: string, N: string, k: string): Env => ({
+    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]: [string, { pred?: string; set?: string }]) => {
+        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] as [string, string, 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: string[] = [];
+
+  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] as const;
+    });
+    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: Expr | undefined, args: string) => {
+    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/src/differential.ts

@@ -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 type { Experiment, Type } from '@bramas/simulant-lang/ir';
+import type { Layout } from '@bramas/simulant-lang/layout';
+import { resolvePub } from '@bramas/simulant-lang/types';
+import { Explorer } from '@bramas/simulant-engine/explorer';
+import { System, type Config } from '@bramas/simulant-engine/system';
+import { canonicalSort, type V } from '@bramas/simulant-engine/values';
+import { generateModel } from './model';
+import { fail } from './translate';
+
+export type DiffReport = { states: number; successors: number; mismatches: string[] };
+
+/** Groups the composed fields by owning component, in component order. */
+function parts(lay: Layout, which: 'world' | 'agentFields') {
+  const owners: string[] = [];
+  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: V, t: Type): string {
+  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 as 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: string, t: Type): string {
+  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: V, t: Type): V {
+  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: V) => normalize(x, t.of));
+    case 'multiset': return canonicalSort(t.of)(v.map((x: V) => 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: Experiment, params: Record<string, V>, leanDir: string, maxStates = 40,
+  mutate: (lean: string) => string = x => x): DiffReport {
+  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: Config['agents'][number]) => `{ 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: Config) => `({ 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: V[]; world: V }): Config => ({
+    agents: c.agents.map((a: V) => ({
+      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: string[] = [];
+  let successors = 0;
+  configs.forEach((C, i) => {
+    const lean = (JSON.parse(lines[i]) as [[string, number][], { agents: V[]; world: V }][])
+      .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/src/library.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 type { Component } from '@bramas/simulant-lang/ir';
+import { resolveComponent } from '@bramas/simulant-lang/standalone';
+import { generateComponent } from './component';
+
+/**
+ * The library's components, from the `.sim` standard library. Their
+ * arguments do not matter: parameters stay symbolic.
+ */
+export const libraryComponents: Component[] = (() => {
+  const elab = stdlibElaborator();
+  return ['Hazards.BlackHole .mayEmerge', 'Faults.CrashStop 1', 'Faults.CrashAtNode', 'Storage.Pebbles',
+    'Frames.PersistentReflection', 'Monitors.Visited'].map(e => resolveComponent(elab.evaluate(e) as Component));
+})();
+
+export const libraryNamespace = (name: string) => `Simulant.Library.${name}`;
+
+export function generateLibrary(dir: URL) {
+  const names: string[] = [];
+  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'));
+}