lemmascript 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemmascript",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "A verification toolchain for TypeScript — generates Lean 4 or Dafny from annotated TS",
   "type": "module",
   "bin": {

package/tools/dist/dafny-commands.js

@@ -31,13 +31,14 @@ export function dafnyCheckDiff(genPath, dfyPath) {
     catch { /* diff not available */ }
     return true;
 }
-export function dafnyVerify(dfyPath, dir, timeLimit) {
+export function dafnyVerify(dfyPath, dir, timeLimit, extraFlags) {
     console.log("Running dafny verify...");
     try {
         const content = readFileSync(dfyPath, "utf-8");
         const stdLibFlag = content.includes("Std.") ? " --standard-libraries" : "";
         const timeLimitFlag = timeLimit ? ` --verification-time-limit ${timeLimit}` : "";
-        execSync(`dafny verify${stdLibFlag}${timeLimitFlag} "${dfyPath}"`, { cwd: dir, stdio: "inherit" });
+        const extra = extraFlags ? ` ${extraFlags}` : "";
+        execSync(`dafny verify${stdLibFlag}${timeLimitFlag}${extra} "${dfyPath}"`, { cwd: dir, stdio: "inherit" });
         return true;
     }
     catch {

package/tools/dist/dafny-emit.js

@@ -14,7 +14,7 @@ function tyToDafny(ty) {
         case "map": return `map<${tyToDafny(ty.key)}, ${tyToDafny(ty.value)}>`;
         case "set": return `set<${tyToDafny(ty.elem)}>`;
         case "optional": {
-            needsOptionType = true;
+            needPreamble("OptionType");
             return `Option<${tyToDafny(ty.inner)}>`;
         }
         case "user": return ty.name;
@@ -55,6 +55,22 @@ const OP_MAP = {
 };
 function mapOp(op) { return OP_MAP[op] ?? op; }
 // ── Expression emission ─────────────────────────────────────
+/** Emit a match scrutinee — either a variable name (string) or an expression. */
+function emitScrutinee(s) {
+    return typeof s === "string" ? escapeName(s) : emitExpr(s);
+}
+/** Collapse nested forall/exists into a single quantifier with multiple bound vars. */
+function emitQuantifier(e, keyword) {
+    const vars = [];
+    let body = e;
+    while (body.kind === e.kind) {
+        const dty = tyToDafny(body.type);
+        const ann = dty === "string" ? "" : `: ${dty}`;
+        vars.push(`${body.var}${ann}`);
+        body = body.body;
+    }
+    return `${keyword} ${vars.join(", ")} :: ${emitExpr(body)}`;
+}
 function emitExpr(e) {
     switch (e.kind) {
         case "var": return e.name === "undefined" ? "None" : escapeName(e.name);
@@ -106,25 +122,25 @@ function emitExpr(e) {
             // String methods
             if (ty === "string") {
                 if (e.method === "indexOf") {
-                    needsStringIndexOf = true;
+                    needPreamble("StringIndexOf");
                     return `StringIndexOf(${obj}, ${args[0]})`;
                 }
                 if (e.method === "slice")
                     return `${obj}[${args[0]}..${args[1]}]`;
                 if (e.method === "trim") {
-                    needsStringTrim = true;
+                    needPreamble("StringTrim");
                     return `StringTrim(${obj})`;
                 }
                 if (e.method === "toLowerCase") {
-                    needsStringToLower = true;
+                    needPreamble("StringToLower");
                     return `StringToLower(${obj})`;
                 }
                 if (e.method === "toUpperCase") {
-                    needsStringToUpper = true;
+                    needPreamble("StringToUpper");
                     return `StringToUpper(${obj})`;
                 }
                 if (e.method === "includes") {
-                    needsStringIndexOf = true;
+                    needPreamble("StringIndexOf");
                     return `(StringIndexOf(${obj}, ${args[0]}) >= 0)`;
                 }
                 if (e.method === "charCodeAt")
@@ -135,7 +151,7 @@ function emitExpr(e) {
                 if (e.method === "getDirect")
                     return `${obj}[${args[0]}]`;
                 if (e.method === "get") {
-                    needsOptionType = true;
+                    needPreamble("OptionType");
                     return `(if ${args[0]} in ${obj} then Some(${obj}[${args[0]}]) else None)`;
                 }
                 if (e.method === "set")
@@ -187,14 +203,14 @@ function emitExpr(e) {
                 if (e.right.kind === "num") {
                     return `(${emitExpr(e.left)} / ${Math.pow(2, e.right.value)})`;
                 }
-                needsPow2 = true;
+                needPreamble("Pow2");
                 return `(${emitExpr(e.left)} / Pow2(${emitExpr(e.right)}))`;
             }
             if (e.op === "<<") {
                 if (e.right.kind === "num") {
                     return `(${emitExpr(e.left)} * ${Math.pow(2, e.right.value)})`;
                 }
-                needsPow2 = true;
+                needPreamble("Pow2");
                 return `(${emitExpr(e.left)} * Pow2(${emitExpr(e.right)}))`;
             }
             // x & mask → x % (mask + 1) for literal masks of form 2^n - 1, else BitAnd
@@ -206,7 +222,7 @@ function emitExpr(e) {
                         return `(${emitExpr(e.left)} % ${modulus})`;
                     }
                 }
-                needsBitAnd = true;
+                needPreamble("BitAnd");
                 return `BitAnd(${emitExpr(e.left)}, ${emitExpr(e.right)})`;
             }
             // int * real coercion: wrap int side with "as real"
@@ -228,7 +244,7 @@ function emitExpr(e) {
         case "app": {
             const args = e.args.map(emitExpr);
             if (e.fn === "SetToSeq") {
-                needsSetToSeq = true;
+                needPreamble("SetToSeq");
                 return `SetToSeq(${args.join(", ")})`;
             }
             if (e.fn === "BigInt" || e.fn === "Number")
@@ -237,19 +253,19 @@ function emitExpr(e) {
             if (e.fn === "SetLiteral")
                 return `{${args.join(", ")}}`;
             if (e.fn === "JSFloorDiv")
-                needsJSFloorDiv = true;
+                needPreamble("JSFloorDiv");
             if (e.fn === "CeilReal")
-                needsCeilReal = true;
+                needPreamble("CeilReal");
             if (e.fn === "FloorReal")
-                needsFloorReal = true;
+                needPreamble("FloorReal");
             if (e.fn === "NatToString")
-                needsNatToString = true;
+                needPreamble("NatToString");
             if (e.fn === "MathAbs")
-                needsMathAbs = true;
+                needPreamble("MathAbs");
             if (e.fn === "MathMin")
-                needsMathMin = true;
+                needPreamble("MathMin");
             if (e.fn === "MathMax")
-                needsMathMax = true;
+                needPreamble("MathMax");
             return `${escapeName(e.fn)}(${args.join(", ")})`;
         }
         case "field": {
@@ -295,7 +311,7 @@ function emitExpr(e) {
                         if (f)
                             return emitExpr(f.value);
                         if (sf.type.kind === "optional") {
-                            needsOptionType = true;
+                            needPreamble("OptionType");
                             return "None";
                         }
                         return `/* missing: ${sf.name} */`;
@@ -311,34 +327,12 @@ function emitExpr(e) {
         case "if":
             return `if ${emitExpr(e.cond)} then ${emitExpr(e.then)} else ${emitExpr(e.else)}`;
         case "match": {
-            const scrut = typeof e.scrutinee === "string" ? escapeName(e.scrutinee) : emitExpr(e.scrutinee);
+            const scrut = emitScrutinee(e.scrutinee);
             const arms = e.arms.map(a => `case ${translatePattern(a.pattern)} => ${emitExpr(a.body)}`);
             return `(match ${scrut} { ${arms.join(" ")} })`;
         }
-        case "forall": {
-            // Collapse nested foralls: forall x :: forall y :: P → forall x, y :: P
-            const vars = [];
-            let body = e;
-            while (body.kind === "forall") {
-                const dty = tyToDafny(body.type);
-                const ann = dty === "string" ? "" : `: ${dty}`;
-                vars.push(`${body.var}${ann}`);
-                body = body.body;
-            }
-            return `forall ${vars.join(", ")} :: ${emitExpr(body)}`;
-        }
-        case "exists": {
-            // Collapse nested exists: exists x :: exists y :: P → exists x, y :: P
-            const vars = [];
-            let body = e;
-            while (body.kind === "exists") {
-                const dty = tyToDafny(body.type);
-                const ann = dty === "string" ? "" : `: ${dty}`;
-                vars.push(`${body.var}${ann}`);
-                body = body.body;
-            }
-            return `exists ${vars.join(", ")} :: ${emitExpr(body)}`;
-        }
+        case "forall": return emitQuantifier(e, "forall");
+        case "exists": return emitQuantifier(e, "exists");
         case "let": return `var ${escapeName(e.name)} := ${emitExpr(e.value)}; ${emitExpr(e.body)}`;
         case "havoc": return "*";
     }
@@ -350,7 +344,7 @@ function emitPureExpr(e, indent) {
         case "if":
             return `${pad}if ${emitExpr(e.cond)} then\n${emitPureExpr(e.then, indent + 1)}\n${pad}else\n${emitPureExpr(e.else, indent + 1)}`;
         case "match": {
-            const scrut = typeof e.scrutinee === "string" ? escapeName(e.scrutinee) : emitExpr(e.scrutinee);
+            const scrut = emitScrutinee(e.scrutinee);
             const lines = [`${pad}match ${scrut} {`];
             for (const arm of e.arms) {
                 lines.push(`${pad}  case ${translatePattern(arm.pattern)} =>`);
@@ -415,7 +409,7 @@ function emitStmt(s, indent) {
             return out;
         }
         case "match": {
-            const scrut = typeof s.scrutinee === "string" ? escapeName(s.scrutinee) : emitExpr(s.scrutinee);
+            const scrut = emitScrutinee(s.scrutinee);
             const lines = [`${pad}match ${scrut} {`];
             for (const arm of s.arms) {
                 lines.push(`${pad}  case ${translatePattern(arm.pattern)} =>`);
@@ -480,8 +474,10 @@ function emitDecl(d) {
             lines.push(`}`);
             // Companion lemma for ensures (proof target for LLM)
             if (d.ensures.length > 0) {
+                // Strip constraints like (==) from type params — ghost lemmas don't need them
+                const lemmaTP = d.typeParams.length > 0 ? `<${d.typeParams.map(t => t.replace(/\(.*\)/, '')).join(", ")}>` : "";
                 lines.push("");
-                lines.push(`lemma ${d.name}_ensures${tp}(${paramList(d.params)})`);
+                lines.push(`lemma ${d.name}_ensures${lemmaTP}(${paramList(d.params)})`);
                 for (const r of d.requires)
                     lines.push(`  requires ${emitExpr(r)}`);
                 for (const e of d.ensures)
@@ -534,21 +530,9 @@ function emitDecl(d) {
 }
 // ── File emission ───────────────────────────────────────────
 // ── Preamble helpers ────────────────────────────────────────
-let needsStringIndexOf = false;
-let needsStringTrim = false;
-let needsStringToLower = false;
-let needsStringToUpper = false;
-let needsJSFloorDiv = false;
-let needsCeilReal = false;
-let needsFloorReal = false;
-let needsOptionType = false;
-let needsSetToSeq = false;
-let needsBitAnd = false;
-let needsPow2 = false;
-let needsNatToString = false;
-let needsMathAbs = false;
-let needsMathMin = false;
-let needsMathMax = false;
+/** Preamble tracking — emitters add keys via `needPreamble(key)`, emitDafnyFile emits them. */
+const _neededPreambles = new Set();
+function needPreamble(key) { _neededPreambles.add(key); }
 const POW2 = `function Pow2(n: int): int
   requires n >= 0
   decreases n
@@ -646,6 +630,41 @@ const NAT_TO_STRING = `function NatToString(n: nat): string
   else NatToString(n / 10) + [digit]
 }`;
 const MATH_ABS = `function MathAbs(x: int): nat { if x >= 0 then x else -x }`;
+const SET_TO_SEQ = `method SetToSeq<T>(s: set<T>) returns (res: seq<T>)
+  ensures forall x :: x in s <==> x in res
+  ensures |res| == |s|
+{
+  var remaining := s;
+  res := [];
+  while remaining != {}
+    invariant remaining <= s
+    invariant forall x :: x in res <==> (x in s && x !in remaining)
+    invariant |res| + |remaining| == |s|
+    decreases remaining
+  {
+    var x :| x in remaining;
+    res := res + [x];
+    remaining := remaining - {x};
+  }
+}`;
+/** Preamble code keyed by name. Emitted in this order when needed. */
+const PREAMBLE_CODE = [
+    ["OptionType", "datatype Option<T> = None | Some(value: T)"],
+    ["SetToSeq", SET_TO_SEQ],
+    ["Pow2", POW2],
+    ["BitAnd", BIT_AND],
+    ["JSFloorDiv", JS_FLOOR_DIV],
+    ["CeilReal", CEIL_REAL],
+    ["FloorReal", FLOOR_REAL],
+    ["StringIndexOf", STRING_INDEX_OF],
+    ["StringTrim", STRING_TRIM],
+    ["StringToLower", STRING_TO_LOWER],
+    ["StringToUpper", STRING_TO_UPPER],
+    ["NatToString", NAT_TO_STRING],
+    ["MathAbs", MATH_ABS],
+    ["MathMin", MATH_MIN],
+    ["MathMax", MATH_MAX],
+];
 // ── Constructor and record helpers ───────────────────────────
 let _recordCtors = new Map();
 let _structureDecls = new Map();
@@ -714,26 +733,9 @@ function translatePattern(pattern) {
     const fieldNames = fields.split(/\s+/).map(escapeName);
     return `${ctorName}(${fieldNames.join(", ")})`;
 }
-const PREAMBLES = {
-    StringIndexOf: STRING_INDEX_OF,
-};
 export function emitDafnyFile(file, tsFileName) {
     buildRecordCtorMap(file.decls);
-    needsStringIndexOf = false;
-    needsStringTrim = false;
-    needsStringToLower = false;
-    needsStringToUpper = false;
-    needsJSFloorDiv = false;
-    needsCeilReal = false;
-    needsFloorReal = false;
-    needsOptionType = false;
-    needsSetToSeq = false;
-    needsBitAnd = false;
-    needsPow2 = false;
-    needsNatToString = false;
-    needsMathAbs = false;
-    needsMathMin = false;
-    needsMathMax = false;
+    _neededPreambles.clear();
     // Collect pure def names so we can skip their method wrappers
     const pureDefs = new Set();
     for (const d of file.decls) {
@@ -770,81 +772,11 @@ export function emitDafnyFile(file, tsFileName) {
     const lines = [];
     if (tsFileName)
         lines.push(`// Generated by lsc from ${tsFileName}`);
-    if (needsOptionType) {
-        lines.push("");
-        lines.push("datatype Option<T> = None | Some(value: T)");
-    }
-    if (needsSetToSeq) {
-        lines.push("");
-        lines.push(`method SetToSeq<T>(s: set<T>) returns (res: seq<T>)
-  ensures forall x :: x in s <==> x in res
-  ensures |res| == |s|
-{
-  var remaining := s;
-  res := [];
-  while remaining != {}
-    invariant remaining <= s
-    invariant forall x :: x in res <==> (x in s && x !in remaining)
-    invariant |res| + |remaining| == |s|
-    decreases remaining
-  {
-    var x :| x in remaining;
-    res := res + [x];
-    remaining := remaining - {x};
-  }
-}`);
-    }
-    if (needsPow2) {
-        lines.push("");
-        lines.push(POW2);
-    }
-    if (needsBitAnd) {
-        lines.push("");
-        lines.push(BIT_AND);
-    }
-    if (needsJSFloorDiv) {
-        lines.push("");
-        lines.push(JS_FLOOR_DIV);
-    }
-    if (needsCeilReal) {
-        lines.push("");
-        lines.push(CEIL_REAL);
-    }
-    if (needsFloorReal) {
-        lines.push("");
-        lines.push(FLOOR_REAL);
-    }
-    if (needsStringIndexOf) {
-        lines.push("");
-        lines.push(PREAMBLES.StringIndexOf);
-    }
-    if (needsStringTrim) {
-        lines.push("");
-        lines.push(STRING_TRIM);
-    }
-    if (needsStringToLower) {
-        lines.push("");
-        lines.push(STRING_TO_LOWER);
-    }
-    if (needsStringToUpper) {
-        lines.push("");
-        lines.push(STRING_TO_UPPER);
-    }
-    if (needsNatToString) {
-        lines.push("");
-        lines.push(NAT_TO_STRING);
-    }
-    if (needsMathAbs) {
-        lines.push("");
-        lines.push(MATH_ABS);
-    }
-    if (needsMathMin) {
-        lines.push("");
-        lines.push(MATH_MIN);
-    }
-    if (needsMathMax) {
-        lines.push("");
-        lines.push(MATH_MAX);
+    for (const [key, code] of PREAMBLE_CODE) {
+        if (_neededPreambles.has(key)) {
+            lines.push("");
+            lines.push(code);
+        }
     }
     lines.push(...declLines);
     return lines.join("\n") + "\n";

package/tools/dist/extract.js

@@ -558,7 +558,9 @@ function extractStmts(stmts) {
                 const nameNode = decl?.getNameNode();
                 if (nameNode && Node.isArrayBindingPattern(nameNode)) {
                     for (const elem of nameNode.getElements()) {
-                        if (Node.isBindingElement(elem))
+                        if (Node.isOmittedExpression(elem))
+                            names.push("_");
+                        else if (Node.isBindingElement(elem))
                             names.push(elem.getNameNode().getText());
                     }
                 }

package/tools/dist/lsc.js

@@ -33,6 +33,12 @@ function main() {
         timeLimit = parseInt(args[timeLimitIdx].split("=")[1]);
         args.splice(timeLimitIdx, 1);
     }
+    const extraFlagsIdx = args.findIndex(a => a.startsWith("--extra-flags="));
+    let extraFlags;
+    if (extraFlagsIdx >= 0) {
+        extraFlags = args[extraFlagsIdx].split("=").slice(1).join("=");
+        args.splice(extraFlagsIdx, 1);
+    }
     const [cmd, filePath] = args;
     if (!cmd || !filePath) {
         console.error("Usage: lsc <gen|check|regen|extract> [--backend=lean|dafny] <file.ts>");
@@ -101,7 +107,7 @@ function main() {
             dafnyGen(genPath, dfyPath, text);
             if (!dafnyCheckDiff(genPath, dfyPath))
                 process.exit(1);
-            if (!dafnyVerify(dfyPath, dir, timeLimit))
+            if (!dafnyVerify(dfyPath, dir, timeLimit, extraFlags))
                 process.exit(1);
             return;
         }