lemmascript 0.5.16 → 0.5.17

package/README.md

@@ -86,6 +86,52 @@ lsc gen --backend=lean src/myModule.ts
 lake build
 ```
 
+## Continuous Integration
+
+LemmaScript ships a **reusable GitHub Actions workflow** that regenerates your artifacts, verifies them, and fails the build if any committed generated file is out of date. Call it from your own repo's workflow:
+
+```yaml
+# .github/workflows/lemmascript.yml
+name: LemmaScript
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  verify:
+    uses: midspiral/LemmaScript/.github/workflows/verify.yml@main
+    with:
+      backend: dafny      # dafny | lean | dafny-slow
+```
+
+The workflow installs the toolchain and (per `backend`) the Dafny or Lean stack, then runs `tools/check.sh`, which batches over a **`LemmaScript-files.txt`** at your repo root. This file is the list of sources CI verifies — you create and maintain it. One entry per line, `filepath [timeout] [extra dafny flags…]`:
+
+```
+src/domain.ts
+src/patch.ts 120
+src/heavy.ts 300 --isolate-assertions
+```
+
+The optional second column is a per-file timeout in seconds; anything after it is passed verbatim to Dafny. The same list drives `lsc check` locally when you run it with no file argument, so CI and your local runs verify exactly the same set. To verify additional Dafny files outside that list, add an executable `check-extra.sh` at the root and it runs automatically (Dafny backends only).
+
+Inputs (all optional):
+
+| Input | Default | Purpose |
+|-------|---------|---------|
+| `backend` | `dafny` | `dafny`, `lean`, or `dafny-slow` (isolate-assertions / long-running proofs) |
+| `node-version` | `24` | Node.js version |
+| `ls-ref` | `main` | LemmaScript ref to verify against |
+| `typecheck` | `true` | Run `npm ci && npm run typecheck` in the calling repo first |
+
+To verify against **both** backends, add a second job with `backend: lean`.
+
+Examples:
+- **[talktimer-lemmascript](https://github.com/midspiral/talktimer-lemmascript/blob/main/.github/workflows/lemmascript.yml)** — Dafny-only.
+- **[pi-lemmascript](https://github.com/midspiral/pi-lemmascript/blob/lemmascript/.github/workflows/lemmascript.yml)** — Dafny + Lean (two jobs).
+
 ## Annotations
 
 ```typescript

package/package.json

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

package/tools/dist/dafny-emit.js

@@ -258,6 +258,10 @@ function emitExpr(e) {
                 if (e.method === "concat")
                     return `(${obj} + [${args.join(", ")}])`;
                 if (e.method === "sort") {
+                    if (args.length === 0) {
+                        needPreamble("SeqSort");
+                        return `SeqSort(${obj})`;
+                    }
                     needPreamble("SeqSortBy");
                     return `SeqSortBy(${obj}, ${args[0]})`;
                 }
@@ -298,6 +302,10 @@ function emitExpr(e) {
                     needPreamble("SeqFindIndex");
                     return `SeqFindIndex(${obj}, ${args[0]})`;
                 }
+                if (e.method === "findLastIndex") {
+                    needPreamble("SeqFindLastIndex");
+                    return `SeqFindLastIndex(${obj}, ${args[0]})`;
+                }
                 if (e.method === "flat" && args.length === 0) {
                     needPreamble("SeqFlatten");
                     return `SeqFlatten(${obj})`;
@@ -306,16 +314,26 @@ function emitExpr(e) {
                     needPreamble("SeqJoin");
                     return `SeqJoin(${obj}, ${args[0]})`;
                 }
-                if (e.method === "some" && e.args[0].kind === "lambda" &&
-                    e.args[0].body.length === 1 && e.args[0].body[0].kind === "return") {
+                // `.some(pred)`: inline a single-return lambda's body, else apply the
+                // predicate (e.g. a function reference).
+                if (e.method === "some") {
                     const lam = e.args[0];
-                    const ret = lam.body[0];
-                    if (ret.kind !== "return")
-                        throw new Error("unreachable");
-                    const { binder: p, body: v } = comprehensionBinder(lam, ret.value, e.obj);
-                    const body = emitExpr(v);
+                    let p, body;
+                    if (lam.kind === "lambda" && lam.body.length === 1 && lam.body[0].kind === "return") {
+                        const cb = comprehensionBinder(lam, lam.body[0].value, e.obj);
+                        p = cb.binder;
+                        body = emitExpr(cb.body);
+                    }
+                    else {
+                        p = escapeName(freshBinder("x", e.obj, e.args[0]));
+                        body = `${args[0]}(${p})`;
+                    }
                     return `(exists ${p} :: ${p} in ${obj} && ${body})`;
                 }
+                // `.reduce(f, init)` → Std's FoldLeft(f, init, xs) (same arg order).
+                if (e.method === "reduce" && args.length === 2) {
+                    return `Std.Collections.Seq.FoldLeft(${args[0]}, ${args[1]}, ${obj})`;
+                }
             }
             // String methods
             if (ty === "string") {
@@ -1006,6 +1024,18 @@ function SeqIndexOfFrom<T(==)>(s: seq<T>, x: T, from: nat): int
   else if s[from] == x then from as int
   else SeqIndexOfFrom(s, x, from + 1)
 }`;
+const SEQ_FIND_LAST_INDEX = `function SeqFindLastIndex<T>(s: seq<T>, p: T -> bool): int
+  ensures -1 <= SeqFindLastIndex(s, p) < |s|
+  ensures SeqFindLastIndex(s, p) >= 0 ==> p(s[SeqFindLastIndex(s, p)])
+  ensures SeqFindLastIndex(s, p) >= 0 ==>
+    (forall j: int :: SeqFindLastIndex(s, p) < j < |s| ==> !p(s[j]))
+  ensures SeqFindLastIndex(s, p) == -1 ==> (forall i: nat :: i < |s| ==> !p(s[i]))
+  decreases |s|
+{
+  if |s| == 0 then -1
+  else if p(s[|s|-1]) then |s| - 1
+  else SeqFindLastIndex(s[..|s|-1], p)
+}`;
 const SEQ_FIND_LAST = `function SeqFindLast<T>(s: seq<T>, p: T -> bool): Option<T>
   ensures SeqFindLast(s, p).Some? ==> p(SeqFindLast(s, p).value)
   ensures SeqFindLast(s, p).Some? ==> SeqFindLast(s, p).value in s
@@ -1032,12 +1062,21 @@ const SEQ_JOIN = `function SeqJoin(s: seq<string>, sep: string): string
   else if |s| == 1 then s[0]
   else s[0] + sep + SeqJoin(s[1..], sep)
 }`;
-const SAFE_SLICE = `function SafeSlice<T>(s: seq<T>, lo: int, hi: int): seq<T>
+const SAFE_SLICE = `function NormalizeSliceIndex(n: nat, i: int): int
+  ensures 0 <= NormalizeSliceIndex(n, i) <= n as int
+{
+  if i < 0 then
+    if n as int + i < 0 then 0 else n as int + i
+  else if i > n as int then n as int
+  else i
+}
+
+function SafeSlice<T>(s: seq<T>, lo: int, hi: int): seq<T>
   ensures |SafeSlice(s, lo, hi)| <= |s|
 {
-  var lo' := if lo < 0 then 0 else if lo > |s| as int then |s| else lo;
-  var hi' := if hi > |s| as int then |s| else if hi < lo' then lo' else hi;
-  s[lo'..hi']
+  var lo' := NormalizeSliceIndex(|s|, lo);
+  var hi' := NormalizeSliceIndex(|s|, hi);
+  if hi' < lo' then [] else s[lo'..hi']
 }`;
 const STRING_INDEX_OF = `function StringIndexOf(s: string, sub: string): int
   ensures StringIndexOf(s, sub) == -1
@@ -1080,6 +1119,10 @@ const STRING_SPLIT = `function {:axiom} StringSplit(s: string, d: string): seq<s
 // is the soundness condition — cmp must be a total preorder, otherwise no sorted
 // permutation exists and the axiom would be vacuous. Callers discharge it (e.g.
 // `(a,b) => a.k - b.k` is total + transitive by linear arithmetic).
+// Bare `.sort()`: permutation only, no sortedness (JS default order is type-dependent).
+const SEQ_SORT = `function {:axiom} SeqSort<T(==,!new)>(s: seq<T>): seq<T>
+  ensures multiset(SeqSort(s)) == multiset(s)
+  ensures |SeqSort(s)| == |s|`;
 const SEQ_SORT_BY = `function {:axiom} SeqSortBy<T(==,!new)>(s: seq<T>, cmp: (T, T) -> int): seq<T>
   requires forall a: T, b: T :: cmp(a, b) <= 0 || cmp(b, a) <= 0
   requires forall a: T, b: T, c: T :: cmp(a, b) <= 0 && cmp(b, c) <= 0 ==> cmp(a, c) <= 0
@@ -1249,6 +1292,7 @@ const PREAMBLE_CODE = [
     ["FloorReal", FLOOR_REAL],
     ["SeqIndexOf", SEQ_INDEX_OF],
     ["SeqFindIndex", SEQ_FIND_INDEX],
+    ["SeqFindLastIndex", SEQ_FIND_LAST_INDEX],
     ["SeqFilterSome", SEQ_FILTER_SOME],
     ["SeqFindLast", SEQ_FIND_LAST],
     ["SeqFlatten", SEQ_FLATTEN],
@@ -1256,6 +1300,7 @@ const PREAMBLE_CODE = [
     ["SafeSlice", SAFE_SLICE],
     ["StringIndexOf", STRING_INDEX_OF],
     ["StringSplit", STRING_SPLIT],
+    ["SeqSort", SEQ_SORT],
     ["SeqSortBy", SEQ_SORT_BY],
     ["StringTrim", STRING_TRIM],
     ["StringToLower", STRING_TO_LOWER],

package/tools/dist/extract.js

@@ -1887,7 +1887,8 @@ export function extractModule(sourceFile) {
             const name = recordMatch[1];
             // `<T extends B>` → bare `T`: a Dafny type param, like the def path.
             const typeParams = recordMatch[2]?.split(",").map(s => s.trim().split(/\s+extends\s+/)[0].trim()).filter(Boolean);
-            const fields = recordMatch[3].split(",").map(f => f.trim()).filter(Boolean).map(f => {
+            // Split on `,` OR `;` — TS object types allow both.
+            const fields = recordMatch[3].split(/[,;]/).map(f => f.trim()).filter(Boolean).map(f => {
                 const [fname, ftype] = f.split(":").map(s => s.trim());
                 const synth = _synthFromTsTypeString(ftype);
                 return { name: fname, tsType: synth ?? ftype };

package/tools/dist/lean-emit.js

@@ -236,6 +236,8 @@ function emitMethodCall(tyKind, method, monadic, obj, args) {
             return `${obj}.${monadic ? "allM" : "all"} ${args[0]}`;
         if (method === "some")
             return `${obj}.${monadic ? "anyM" : "any"} ${args[0]}`;
+        if (method === "reduce" && args.length === 2)
+            return `(${obj}.foldl ${args[0]} ${args[1]})`;
         if (method === "includes")
             return args.length > 1 ? `(${obj}.extract ${args[1]} ${obj}.size).contains ${args[0]}` : `${obj}.contains ${args[0]}`;
         if (method === "find")
@@ -476,8 +478,13 @@ function emitExpr(e, parentPrec) {
             // A real value reached the Lean backend via coercion (e.g. number `/`).
             // Same unsupported-real story as the `real` type case in tyToLean.
             throw new Error("real arithmetic is not supported by the Lean backend (needs noncomputable ℝ / Mathlib).");
-        case "index":
-            return `${emitExpr(e.arr)}[${emitExpr(e.idx)}]!`;
+        case "index": {
+            const arr = emitExpr(e.arr);
+            // Parenthesize a low-precedence array expr (e.g. a function application)
+            // so the index binds to the whole thing, not its last token.
+            const wrap = e.arr.kind === "app" || e.arr.kind === "binop" || e.arr.kind === "methodCall" || e.arr.kind === "if" || e.arr.kind === "let" || e.arr.kind === "unop";
+            return `${wrap ? `(${arr})` : arr}[${emitExpr(e.idx)}]!`;
+        }
         case "record": {
             const fields = e.fields.map(f => `${escapeName(f.name)} := ${emitExpr(f.value)}`);
             if (e.spread)
@@ -652,6 +659,59 @@ function emitStmt(s, indent) {
     }
 }
 // ── Declaration emission ─────────────────────────────────────
+/** Collect every function/variable name an IR tree references (stripping any
+ *  `Pure.` qualifier), via a generic walk over `app`/`var` nodes. */
+function collectRefNames(node, into) {
+    if (node === null || typeof node !== "object")
+        return;
+    if (Array.isArray(node)) {
+        for (const x of node)
+            collectRefNames(x, into);
+        return;
+    }
+    const n = node;
+    if (n.kind === "app" && typeof n.fn === "string")
+        into.add(n.fn.replace(/^Pure\./, ""));
+    if (n.kind === "var" && typeof n.name === "string")
+        into.add(n.name.replace(/^Pure\./, ""));
+    for (const k of Object.keys(node))
+        collectRefNames(node[k], into);
+}
+/** Lean requires definition-before-use: order sibling decls so one that
+ *  references another is emitted after it. Cycles are left in place (they would
+ *  need a `mutual` block). Bails to the original order if any decl is unnamed. */
+function orderDeclsByDeps(decls) {
+    const named = decls.filter((d) => typeof d.name === "string");
+    if (named.length !== decls.length)
+        return decls;
+    const names = new Set(named.map(d => d.name));
+    const byName = new Map(named.map(d => [d.name, d]));
+    const deps = new Map();
+    for (const d of named) {
+        const refs = new Set();
+        collectRefNames(d, refs);
+        refs.delete(d.name);
+        deps.set(d.name, [...refs].filter(r => names.has(r)));
+    }
+    const sorted = [];
+    const done = new Set();
+    const onStack = new Set();
+    const visit = (name) => {
+        if (done.has(name) || onStack.has(name))
+            return;
+        onStack.add(name);
+        for (const dep of deps.get(name) ?? [])
+            visit(dep);
+        onStack.delete(name);
+        done.add(name);
+        const def = byName.get(name);
+        if (def)
+            sorted.push(def);
+    };
+    for (const d of named)
+        visit(d.name);
+    return sorted;
+}
 function emitDecl(d) {
     switch (d.kind) {
         case "inductive": {
@@ -730,7 +790,7 @@ function emitDecl(d) {
         }
         case "namespace": {
             const lines = [`namespace ${d.name}`];
-            for (const inner of d.decls)
+            for (const inner of orderDeclsByDeps(d.decls))
                 lines.push("", emitDecl(inner));
             lines.push("", `end ${d.name}`);
             return lines.join("\n");
@@ -752,8 +812,10 @@ function emitDecl(d) {
                 return sig;
             // Spec axiom: ∀ params, req1 → … → (ens1 ∧ … ∧ ensN). Tagged `@[grind]` so
             // the proof automation can use it, matching the ghost-function convention.
-            const hyps = d.requires.map(emitExpr);
-            const concl = d.ensures.map(emitExpr).join(" ∧ ");
+            // Parenthesize each clause: an unwrapped `∀ k, P` would otherwise swallow
+            // the following ` ∧ …` conjuncts into its body.
+            const hyps = d.requires.map(e => `(${emitExpr(e)})`);
+            const concl = d.ensures.map(e => `(${emitExpr(e)})`).join(" ∧ ");
             const axBody = [...hyps, concl].join(" → ");
             const axiom = `@[grind] axiom ${escapeName(d.name)}_spec${params ? ` ${params}` : ""} : ${axBody}`;
             return `${sig}\n${axiom}`;

package/tools/dist/narrow.js

@@ -260,51 +260,86 @@ function ruleEarlyReturnConsume(s, rest) {
         noneBody: noneBranch,
     };
 }
-/** Collect a `||` chain of negative optional checks (`x === undefined`).
- *  Returns the list of checks if every leaf is a negative optional check; null otherwise. */
-function collectOrChainOfNegativeChecks(cond) {
-    if (cond.kind === "binop" && cond.op === "||") {
-        const left = collectOrChainOfNegativeChecks(cond.left);
-        const right = collectOrChainOfNegativeChecks(cond.right);
-        if (!left || !right)
-            return null;
-        return [...left, ...right];
+/** Flatten a nested `||` chain into its leaf conditions. */
+function flattenOr(e) {
+    if (e.kind === "binop" && e.op === "||")
+        return [...flattenOr(e.left), ...flattenOr(e.right)];
+    return [e];
+}
+function classifyDisjunct(leaf) {
+    // `x?.chain !== lit` — `undefined !== lit` is true when x is None.
+    if (leaf.kind === "binop" && leaf.op === "!==") {
+        const oc = leaf.left.kind === "optChain" ? leaf.left : leaf.right.kind === "optChain" ? leaf.right : null;
+        if (oc && oc.kind === "optChain" && oc.obj.ty.kind === "optional") {
+            const hint = binderHintFor(oc.obj);
+            if (hint === null)
+                return null;
+            const binder = freshName(hint);
+            const unwrapped = applyChain({ kind: "var", name: binder, ty: oc.obj.ty.inner }, oc.chain);
+            if (unwrapped.kind === "field" && unwrapped.obj.ty.kind === "user") {
+                const base = unwrapped.obj.ty.name.replace(/<.*/, "");
+                const decl = _typeDecls.find(d => d.name === base);
+                if (decl?.kind === "discriminated-union" && decl.discriminant === unwrapped.field)
+                    unwrapped.isDiscriminant = true;
+            }
+            const lit = leaf.left === oc ? leaf.right : leaf.left;
+            return { scrutinee: oc.obj, innerTy: oc.obj.ty.inner, binder, residual: { kind: "binop", op: "!==", left: unwrapped, right: lit, ty: { kind: "bool" } } };
+        }
     }
-    const check = parseSimpleOptionalCheck(cond);
-    if (!check || !check.negated)
-        return null;
-    return [check];
+    // `!x` / `x === undefined`.
+    const chk = parseOptionalCheck(leaf);
+    if (chk && chk.negated) {
+        const residual = canBeFalsy(chk)
+            ? { kind: "unop", op: "!", expr: { kind: "var", name: chk.binderHint, ty: chk.innerTy }, ty: { kind: "bool" } }
+            : null;
+        return { scrutinee: chk.scrutinee, innerTy: chk.innerTy, binder: chk.binderHint, residual };
+    }
+    return null;
 }
-/** Rule: `if (x === undefined || y === undefined || ...) terminate; rest`.
- *  → nested someMatches narrowing each var in turn, each None branch = terminate,
- *    deepest someBody = rest.
+/** Rule: `if (D1 || … || Dn) terminate; rest`. Each `Di` that detects some optional
+ *  `x` is None (`!x`, `x === undefined`, `x?.chain !== lit`) narrows that `x` to Some
+ *  across `rest`; the rest — value guards reading a narrowed `x` directly, plus the
+ *  detectors' Some-case residuals — become a trailing early-return. Sound: reaching
+ *  `rest` means every disjunct was false, so every detected optional is present.
+ *  Covers `if (!x || x.f !== v) continue` / `if (x?.t !== 'm' || x.g) break`.
  *  Closes the resolve.ts:602 TODO ("|| narrowing"). */
 function ruleEarlyReturnOrChain(s, rest) {
     if (s.kind !== "if")
         return null;
     if (rest.length === 0)
         return null;
-    if (s.then.length === 0 || s.else.length !== 0)
+    if (s.then.length === 0 || s.else.length !== 0 || !isTerminating(s.then))
         return null;
     if (s.cond.kind !== "binop" || s.cond.op !== "||")
         return null; // single check is the simpler rule
-    const checks = collectOrChainOfNegativeChecks(s.cond);
-    if (!checks || checks.length < 2)
-        return null;
-    // Build nested someMatch from innermost outward
-    let inner = rest;
-    for (let i = checks.length - 1; i >= 0; i--) {
-        const check = checks[i];
-        const someBody = canBeFalsy(check)
-            ? [{ kind: "if", cond: bound(check), then: inner, else: s.then }]
-            : inner;
-        inner = [{
-                kind: "someMatch",
-                scrutinee: check.scrutinee, binderTy: check.innerTy,
-                binder: check.binderHint,
-                someBody,
-                noneBody: s.then,
-            }];
+    const leaves = flattenOr(s.cond);
+    if (leaves.length < 2)
+        return null;
+    const detectors = [];
+    const residualLeaves = [];
+    const seen = new Set();
+    for (const leaf of leaves) {
+        const d = classifyDisjunct(leaf);
+        if (!d) {
+            residualLeaves.push(leaf);
+            continue;
+        }
+        const key = binderHintFor(d.scrutinee);
+        if (seen.has(key))
+            return null; // two detectors on one optional: rare; leave to other rules
+        seen.add(key);
+        detectors.push(d);
+        if (d.residual)
+            residualLeaves.push(d.residual);
+    }
+    if (detectors.length === 0)
+        return null;
+    let inner = residualLeaves.length === 0
+        ? rest
+        : [{ kind: "if", cond: residualLeaves.reduce((a, b) => ({ kind: "binop", op: "||", left: a, right: b, ty: { kind: "bool" } })), then: s.then, else: [] }, ...rest];
+    for (let i = detectors.length - 1; i >= 0; i--) {
+        const d = detectors[i];
+        inner = [{ kind: "someMatch", scrutinee: d.scrutinee, binderTy: d.innerTy, binder: d.binder, someBody: inner, noneBody: s.then }];
     }
     return inner[0];
 }

package/tools/dist/resolve.js

@@ -480,8 +480,19 @@ function inferLambdaParamTypes(fn, rawArgs, ctx) {
             return [{ ...lam, params: updatedParams }, ...rawArgs.slice(1)];
         }
     }
+    // reduce's callback is (acc, elem): acc from the init arg's type, elem from the array.
+    if (fn.kind === "field" && fn.obj.ty.kind === "array" && fn.field === "reduce" && ctx &&
+        rawArgs.length >= 2 && rawArgs[0].kind === "lambda" && rawArgs[0].params.length >= 2) {
+        const accTs = tyToTsStr(resolveExpr(rawArgs[1], ctx).ty);
+        const elemTs = tyToTsStr(fn.obj.ty.elem);
+        if (accTs && elemTs) {
+            const lam = rawArgs[0];
+            const updatedParams = lam.params.map((p, i) => p.tsType || i > 1 ? p : { ...p, tsType: i === 0 ? accTs : elemTs });
+            return [{ ...lam, params: updatedParams }, ...rawArgs.slice(1)];
+        }
+    }
     if (fn.kind === "field" && fn.obj.ty.kind === "array" &&
-        ["map", "filter", "every", "some", "find", "findLast", "findIndex"].includes(fn.field) &&
+        ["map", "filter", "every", "some", "find", "findLast", "findIndex", "findLastIndex"].includes(fn.field) &&
         rawArgs.length >= 1 && rawArgs[0].kind === "lambda" &&
         rawArgs[0].params.length >= 1 && !rawArgs[0].params[0].tsType) {
         const elemTy = fn.obj.ty.elem;
@@ -604,9 +615,11 @@ function inferMethodReturnTy(fn, args, ctx) {
             return objTy;
         if (fn.field === "every" || fn.field === "some")
             return { kind: "bool" };
+        if (fn.field === "reduce" && args.length === 2)
+            return args[1].ty;
         if (fn.field === "find" || fn.field === "findLast")
             return { kind: "optional", inner: objTy.elem };
-        if (fn.field === "findIndex")
+        if (fn.field === "findIndex" || fn.field === "findLastIndex")
             return { kind: "int" };
         if (fn.field === "flat" && objTy.elem.kind === "array")
             return { kind: "array", elem: objTy.elem.elem };

package/tools/dist/transform.js

@@ -189,6 +189,12 @@ export const DAFNY_OPTIONS = {
 let _opts = DAFNY_OPTIONS;
 /** Type declarations — set once per module transform for discriminated union handling. */
 let _typeDecls = [];
+/** Names of functions that get a `Pure.` mirror (Lean). A bare reference to one
+ *  in a higher-order position resolves to the monadic method, so it must be
+ *  redirected to the pure mirror. Set once per module transform. */
+let _pureDefNames = new Set();
+/** Array methods that take a function argument. */
+const HOF_METHODS = new Set(["map", "filter", "every", "some", "find", "findLast", "findIndex", "findLastIndex", "reduce"]);
 /** Prefix match-bound field names to avoid capturing user variables.
  *  When prefix is given (the scrutinee name), include it to avoid
  *  collisions in nested matches on different variables. `freshName` closes
@@ -331,7 +337,8 @@ function coerceCondToBool(cond, ty) {
         return { kind: "binop", op: "≠", left: cond, right: { kind: "num", value: 0 } };
     if (ty.kind === "string")
         return { kind: "binop", op: ">", left: { kind: "field", obj: cond, field: "length" }, right: { kind: "num", value: 0 } };
-    if (ty.kind === "array")
+    // Arrays, objects, maps, sets, tuples are always truthy in JS (even `[]`/`{}`).
+    if (["array", "user", "map", "set", "tuple"].includes(ty.kind))
         return { kind: "bool", value: true };
     return cond;
 }
@@ -608,6 +615,13 @@ function lowerExpr(e, binds) {
                     else: { kind: "var", name: "undefined" },
                 };
             }
+            // || on a number → `if x != 0 then x else default` (0 the only falsy int).
+            if (e.op === "||" && (e.left.ty.kind === "int" || e.left.ty.kind === "nat")) {
+                const left = lowerExpr(e.left, binds);
+                const right = lowerExpr(e.right, binds);
+                const truthy = valueTruthyCond(left, e.left.ty);
+                return { kind: "if", cond: truthy, then: left, else: right };
+            }
             // String concatenation: `+` with a string operand. Stringify int/nat
             // operands (Dafny NatToString, Lean toString) and join with arrayConcat
             // (rendered `+` in Dafny, `++` in Lean).
@@ -773,8 +787,15 @@ function lowerExpr(e, binds) {
             if (e.fn.kind === "field") {
                 const recv = lowerExpr(e.fn.obj, binds);
                 let method = e.fn.field;
+                const isHOF = e.fn.obj.ty.kind === "array" && HOF_METHODS.has(method);
                 const args = e.args.map((a, i) => {
                     const lowered = lowerExpr(a, binds);
+                    // Lean: a pure fn passed to a HOF by name resolves to the monadic
+                    // method; redirect to its pure `Pure.` mirror.
+                    if (_opts.backend === "lean" && isHOF &&
+                        lowered.kind === "var" && _pureDefNames.has(lowered.name)) {
+                        return { kind: "var", name: `Pure.${lowered.name}` };
+                    }
                     // Array index args must be nat in Lean: `with`'s index (0), includes/indexOf `from` (1).
                     const isArrIdxArg = e.fn.kind === "field" && e.fn.obj.ty.kind === "array" &&
                         ((e.fn.field === "with" && i === 0) || ((e.fn.field === "includes" || e.fn.field === "indexOf") && i === 1));
@@ -2182,6 +2203,7 @@ export function transformModule(mod, specImport, moduleBaseOverride) {
     _forofCounters.clear();
     _liftCounter = 0;
     _typeDecls = mod.typeDecls;
+    _pureDefNames = new Set(mod.functions.filter(f => f.isPure).map(f => f.name));
     const typeDecls = mod.typeDecls.map(transformTypeDecl);
     // Module-level constants
     const constDecls = (mod.constants ?? []).map(c => ({