tla-ts 0.0.10-dev.c92e6a4ea → 0.0.10-dev.d166e0ae9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (235) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +54 -54
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +13 -3
  7. package/dist/index.d.ts +13 -3
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +68 -68
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +42 -42
  16. package/dist/run.js +44 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +45 -43
  20. package/dist/transfer.js +45 -43
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +11 -1
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +9 -6
  28. package/src/check-trace.ts +116 -64
  29. package/src/check.ts +356 -173
  30. package/src/cli/tlc-output.ts +1 -0
  31. package/src/cli/tlc.ts +4 -3
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +34 -13
  34. package/src/coverage.ts +3 -0
  35. package/src/dependencies.ts +61 -13
  36. package/src/dfid.ts +22 -10
  37. package/src/environment.ts +71 -35
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +149 -54
  40. package/src/exit-codes.ts +29 -15
  41. package/src/instances.ts +16 -6
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +186 -97
  45. package/src/liveness-checker.ts +131 -83
  46. package/src/liveness.ts +52 -11
  47. package/src/obligations/index.ts +1 -1
  48. package/src/obligations/normalize.ts +1 -4
  49. package/src/obligations/printer.ts +5 -5
  50. package/src/obligations/source.ts +2 -0
  51. package/src/parser.ts +115 -145
  52. package/src/prover/isabelle/isar/attrib.ts +4 -4
  53. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  54. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  55. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  56. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  57. package/src/prover/isabelle/pure/term.ts +3 -3
  58. package/src/prover/prep/md5.ts +26 -29
  59. package/src/prover/smt/rewrite.ts +2 -7
  60. package/src/prover/smt/simplify.ts +1 -1
  61. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  62. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  63. package/src/prover/smt/solver/asserted-formulas.ts +169 -58
  64. package/src/prover/smt/solver/ast-lt.ts +1 -1
  65. package/src/prover/smt/solver/ast.ts +63 -14
  66. package/src/prover/smt/solver/auf-solver.ts +23 -12
  67. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  68. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  69. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  70. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  71. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  72. package/src/prover/smt/solver/card2bv.ts +35 -18
  73. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  74. package/src/prover/smt/solver/context.ts +67 -13
  75. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  76. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  77. package/src/prover/smt/solver/dependent-expr-state.ts +26 -15
  78. package/src/prover/smt/solver/diff-neq.ts +1 -2
  79. package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
  80. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  81. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  82. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  83. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  84. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  87. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  88. package/src/prover/smt/solver/euf/mam.ts +1 -5
  89. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  90. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  91. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  92. package/src/prover/smt/solver/factor.ts +36 -14
  93. package/src/prover/smt/solver/fd-solver.ts +148 -39
  94. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  95. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  96. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  97. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  98. package/src/prover/smt/solver/goal.ts +6 -3
  99. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  100. package/src/prover/smt/solver/hashtable.ts +4 -0
  101. package/src/prover/smt/solver/internalizer.ts +1 -1
  102. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  103. package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
  104. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  105. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  106. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  107. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  108. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  109. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  110. package/src/prover/smt/solver/maxcore.ts +2 -1
  111. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  112. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  113. package/src/prover/smt/solver/model-checker.ts +1 -1
  114. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  115. package/src/prover/smt/solver/model-generator.ts +85 -43
  116. package/src/prover/smt/solver/mpf.ts +2 -4
  117. package/src/prover/smt/solver/mus.ts +2 -3
  118. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  119. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  120. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  121. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  122. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  123. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  124. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  125. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  126. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  127. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  128. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  129. package/src/prover/smt/solver/nlqsat.ts +1 -1
  130. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  131. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  132. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  133. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  134. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  135. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  136. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  137. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  138. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  139. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  140. package/src/prover/smt/solver/nnf.ts +6 -2
  141. package/src/prover/smt/solver/opt-context.ts +21 -7
  142. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  143. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  144. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  145. package/src/prover/smt/solver/opt-solver.ts +10 -6
  146. package/src/prover/smt/solver/optsmt.ts +1 -1
  147. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  148. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  149. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  150. package/src/prover/smt/solver/probes.ts +88 -23
  151. package/src/prover/smt/solver/proto-model.ts +8 -8
  152. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  153. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  154. package/src/prover/smt/solver/qe-lite.ts +2 -2
  155. package/src/prover/smt/solver/qe.ts +3 -2
  156. package/src/prover/smt/solver/qsat.ts +23 -8
  157. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  158. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  159. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  160. package/src/prover/smt/solver/rewriter.ts +31 -25
  161. package/src/prover/smt/solver/rlimit.ts +4 -0
  162. package/src/prover/smt/solver/sat/config.ts +1 -1
  163. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  164. package/src/prover/smt/solver/sat/inc-sat-solver.ts +81 -28
  165. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  166. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  167. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  168. package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
  169. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  170. package/src/prover/smt/solver/sat/solver.ts +25 -47
  171. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  172. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  173. package/src/prover/smt/solver/seq-derive.ts +2 -2
  174. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  175. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  176. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  177. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  178. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  179. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  180. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  181. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  182. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  183. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  184. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  185. package/src/prover/smt/solver/smt-setup.ts +96 -10
  186. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  187. package/src/prover/smt/solver/smtlib-script.ts +674 -195
  188. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  189. package/src/prover/smt/solver/solver.ts +18 -3
  190. package/src/prover/smt/solver/tactic.ts +332 -189
  191. package/src/prover/smt/solver/theory-bv.ts +13 -3
  192. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  193. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  194. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  195. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  196. package/src/prover/smt/solver/theory-lra.ts +1 -1
  197. package/src/prover/smt/solver/theory-pb.ts +24 -7
  198. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  199. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  200. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  201. package/src/prover/tlapm/cache.ts +8 -8
  202. package/src/prover/zenon/index-table.ts +5 -2
  203. package/src/prover/zenon/isar-case.ts +1 -1
  204. package/src/prover/zenon/isar.ts +2 -2
  205. package/src/prover/zenon/phrase.ts +1 -1
  206. package/src/resolve.ts +1071 -251
  207. package/src/runtime.ts +5 -1
  208. package/src/sany/builtins.ts +10 -10
  209. package/src/sany/generation.ts +2 -13
  210. package/src/sany/generator-definitions.ts +3 -1
  211. package/src/sany/generator-expressions.ts +38 -30
  212. package/src/sany/generator-proofs.ts +6 -3
  213. package/src/sany/generator.ts +2 -1
  214. package/src/sany/lexer.ts +3 -3
  215. package/src/sany/modules.ts +4 -2
  216. package/src/sany/nodes.ts +1 -1
  217. package/src/sany/selectors.ts +11 -6
  218. package/src/sany/xml.ts +2 -3
  219. package/src/search.ts +197 -117
  220. package/src/simulate.ts +165 -102
  221. package/src/spec-description.ts +8 -6
  222. package/src/standard-modules.ts +56 -22
  223. package/src/subexpressions.ts +518 -123
  224. package/src/successors.ts +10 -3
  225. package/src/symmetry.ts +2 -1
  226. package/src/tlc/jar-data.ts +10 -0
  227. package/src/tlc/messages.ts +3 -3
  228. package/src/tlc/random.ts +2 -1
  229. package/src/tlc/replay.ts +27 -14
  230. package/src/tlc/tlc-operators.ts +10 -8
  231. package/src/tlc/tlcext-operators.ts +26 -10
  232. package/src/tlc/trace-spec.ts +9 -22
  233. package/src/typed-tier.ts +44 -27
  234. package/src/typescript/types.ts +2 -2
  235. package/src/values.ts +135 -78
@@ -548,6 +548,7 @@ export const printResult = (result: CheckResult, printer: MessagePrinter, timing
548
548
  printTrace(printer, failure.trace, "error-trace");
549
549
  const traceFailure = failure.traceFailure;
550
550
  if (traceFailure) {
551
+ printTraceOutput(printer, traceFailure.output);
551
552
  print(
552
553
  traceFailure.code,
553
554
  MESSAGE_LEVEL.error,
package/src/cli/tlc.ts CHANGED
@@ -280,8 +280,9 @@ const checkSpec = async (
280
280
  } else {
281
281
  printError(error, printer);
282
282
  }
283
- printFinished();
284
- return getTopLevelExitCode(error);
283
+ const exitCode = getTopLevelExitCode(error);
284
+ if (exitCode !== EXIT_STATUS.abort) printFinished();
285
+ return exitCode;
285
286
  };
286
287
  const config = (() => {
287
288
  try {
@@ -591,7 +592,7 @@ export const checkSpecs = async (args: string[], java: JavaProperties) => {
591
592
  exitCodes.push(
592
593
  await reportErrors(async () => {
593
594
  const specPath = path.endsWith(".ts") ? await writeTypeScriptSpec(path) : path;
594
- // Deviation from TLC: TLC checks one spec, so tla-ts names each of several it checks.
595
+ // An extension: TLC refuses more than one spec, and tla-ts checks each one under its name.
595
596
  if (paths.length > 1) {
596
597
  console.log(`Checking ${basename(specPath)} with ${basename(specPath, ".tla")}.cfg`);
597
598
  }
@@ -52,7 +52,7 @@ const XML_EXPORT_USAGE = (() => {
52
52
  "",
53
53
  getBold("OPTIONS"),
54
54
  "",
55
- ...options.map(([flag, description]) => `\t${getBold(flag)}\n\t\t${description}`),
55
+ ...options.map((option) => `\t${getBold(option[0])}\n\t\t${option[1]}`),
56
56
  "",
57
57
  getBold("TIPS"),
58
58
  "",
package/src/codegen.ts CHANGED
@@ -14,6 +14,7 @@ import {
14
14
  getFunctionBuilder,
15
15
  getLazyFilter,
16
16
  isKeptLazy,
17
+ isUniformPredicate,
17
18
  getDomainOperator,
18
19
  getSubsetOperator,
19
20
  getEvaluator,
@@ -161,23 +162,37 @@ const createLocal = (generator: Generator) => `local${generator.counter++}`;
161
162
  const getFreeNames = (expression: Expression, names = new Set<string>()) => {
162
163
  const name = getReferencedName(expression);
163
164
  if (name !== undefined) names.add(name);
164
- getChildren(expression).forEach((child) => getFreeNames(child, names));
165
+ if (expression.kind !== "Selection") {
166
+ getChildren(expression).forEach((child) => getFreeNames(child, names));
167
+ }
165
168
  return names;
166
169
  };
167
170
 
168
- const getDelegateContext = (generator: Generator, expression: Expression, frame: Frame) => {
171
+ const getDelegateContext = (
172
+ generator: Generator,
173
+ expression: Expression,
174
+ frame: Frame,
175
+ isEveryLocalCaptured = false,
176
+ ) => {
169
177
  const freeNames = getFreeNames(expression);
170
- const captured = [...frame.locals].filter(([name]) => freeNames.has(name));
178
+ const captured = [...frame.locals].filter(
179
+ (entry) => isEveryLocalCaptured || freeNames.has(entry[0]),
180
+ );
171
181
  if (captured.length === 0) return frame.context;
172
182
  const names = addReference(
173
183
  generator,
174
- captured.map(([name]) => name),
184
+ captured.map((entry) => entry[0]),
175
185
  );
176
- return `extend(${frame.context}, ${names}, [${captured.map(([, local]) => local).join(", ")}])`;
186
+ return `extend(${frame.context}, ${names}, [${captured.map((entry) => entry[1]).join(", ")}])`;
177
187
  };
178
188
 
179
- const generateDelegate = (generator: Generator, expression: Expression, frame: Frame) =>
180
- `${addReference(generator, getEvaluator(expression, generator.environment))}(${getDelegateContext(generator, expression, frame)})`;
189
+ const generateDelegate = (
190
+ generator: Generator,
191
+ expression: Expression,
192
+ frame: Frame,
193
+ isEveryLocalCaptured = false,
194
+ ) =>
195
+ `${addReference(generator, getEvaluator(expression, generator.environment))}(${getDelegateContext(generator, expression, frame, isEveryLocalCaptured)})`;
181
196
 
182
197
  const generateHelper = (
183
198
  generator: Generator,
@@ -267,7 +282,8 @@ const generateSetFilter = (
267
282
  const lazy = `if (!isReducible(${base})) return ${filterLazily}(${base}, ${getDelegateContext(generator, expression, bodyFrame)});`;
268
283
  const set = generateExpression(generator, expression.bound.set, bodyFrame);
269
284
  bodyFrame.locals.set(name, element);
270
- const test = `if (filterPredicate(${generateExpression(generator, expression.predicate, bodyFrame)}, ${node})) addBounded(${kept}, ${element});`;
285
+ const stop = isUniformPredicate(expression, generator.environment) ? " else break;" : "";
286
+ const test = `if (filterPredicate(${generateExpression(generator, expression.predicate, bodyFrame)}, ${node})) addBounded(${kept}, ${element});${stop}`;
271
287
  return `const ${base} = ${set}; ${lazy} const ${list} = ${base}.kind === "Interval" ? ${base} : finiteElements(${base}); const ${kept} = []; ${generateLoop(generator, list, element, test)} return normalizedSet(${kept});`;
272
288
  });
273
289
 
@@ -318,9 +334,10 @@ const generateApply = (
318
334
  const domain = addReference(generator, getDomainOperator(expression));
319
335
  return `${domain}(${generateExpression(generator, args[0], frame)})`;
320
336
  }
321
- if (builtin.name === "TLCEval") return generateDelegate(generator, expression, frame);
322
- if (builtin.name === "\\subseteq" && args.length === 2) {
323
- const subset = addReference(generator, getSubsetOperator(expression, builtin));
337
+ // TLC caches a constant TLCEval only where no name is bound, so the delegate sees every local.
338
+ if (builtin.name === "TLCEval") return generateDelegate(generator, expression, frame, true);
339
+ if (builtin.name === "\\subseteq" && builtin.evaluateBinary && args.length === 2) {
340
+ const subset = addReference(generator, getSubsetOperator(expression, builtin.evaluateBinary));
324
341
  return `${subset}(${generateExpression(generator, args[0], frame)}, ${generateExpression(generator, args[1], frame)})`;
325
342
  }
326
343
  const environment = generator.environment;
@@ -440,12 +457,16 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
440
457
  generator,
441
458
  fields.map((field) => field.name),
442
459
  );
443
- const values = `[${fields.map((field) => generate(field.value)).join(", ")}]`;
460
+ const values = `[${expression.fields.map((field) => generate(field.value)).join(", ")}]`;
444
461
  const writtenNames = expression.fields.map((field) => field.name);
445
462
  if (writtenNames.every((name, index) => name === fields[index].name)) {
446
463
  return `record(${names}, ${values})`;
447
464
  }
448
- return `writtenRecord(${names}, ${values}, ${addReference(generator, writtenNames)})`;
465
+ const writtenIndexes = addReference(
466
+ generator,
467
+ fields.map((field) => expression.fields.indexOf(field)),
468
+ );
469
+ return `writtenRecord(${names}, ${writtenIndexes}, ${values}, ${addReference(generator, writtenNames)})`;
449
470
  }
450
471
  case "Tuple":
451
472
  return `tuple([${expression.elements.map((element) => generate(element)).join(", ")}])`;
package/src/coverage.ts CHANGED
@@ -380,6 +380,9 @@ export const buildCoverage = (
380
380
  case "Lambda":
381
381
  walk(expression.body, bindNames(expression.params, locals));
382
382
  return;
383
+ case "Selection":
384
+ walk(expression.expression, locals);
385
+ return;
383
386
  case "Let": {
384
387
  const inner = expression.definitions.reduce<Local | undefined>(
385
388
  (parent, definition) => ({ name: definition.name, definition, scope: undefined, parent }),
@@ -29,6 +29,7 @@ const VARIABLE_LEVEL_FLAGS = 32;
29
29
  const ACTION_LEVEL_FLAGS = VARIABLE_LEVEL_FLAGS | 64;
30
30
  const TEMPORAL_LEVEL_FLAGS = ACTION_LEVEL_FLAGS | 128;
31
31
  const RANDOM = 256;
32
+ const ABOVE_CONSTANT_BOUND = 512;
32
33
 
33
34
  const ACTION_KINDS = new Set<Expression["kind"]>([
34
35
  "Prime",
@@ -80,6 +81,7 @@ interface Edge {
80
81
  callee: Definition;
81
82
  isOverridden: boolean;
82
83
  isLevelCounted: boolean;
84
+ isOperatorArgument: boolean;
83
85
  }
84
86
 
85
87
  const collectLocalFacts = (
@@ -104,20 +106,34 @@ const collectLocalFacts = (
104
106
  }
105
107
  return undefined;
106
108
  };
107
- const visit = (node: Expression, isLevelCounted: boolean) => {
109
+ const contexts = new Map<Expression, number>();
110
+ const visit = (node: Expression, isLevelCounted: boolean, isOperatorArgument: boolean) => {
108
111
  const kind = node.kind;
112
+ if (kind === "Selection") {
113
+ const seen = contexts.get(node.expression) ?? 0;
114
+ const context = isLevelCounted ? (isOperatorArgument ? 1 : 2) : isOperatorArgument ? 4 : 8;
115
+ if ((seen & context) !== 0) return;
116
+ contexts.set(node.expression, seen | context);
117
+ }
118
+ // TLC's getLevelBound takes an operator argument for a constant.
119
+ const nonconstantFlags = isOperatorArgument ? NONCONSTANT : NONCONSTANT | ABOVE_CONSTANT_BOUND;
109
120
  if (
110
121
  NONCONSTANT_KINDS.has(kind) ||
111
122
  (kind === "UnboundedQuantifier" && node.isTemporal === true) ||
112
123
  (kind === "Apply" && NONCONSTANT_OPERATORS.has(node.operator))
113
124
  ) {
114
- row[0] |= NONCONSTANT;
125
+ row[0] |= nonconstantFlags;
115
126
  }
116
127
  if (NONCONSTANT_KINDS.has(kind)) row[0] |= READS_IMPURE;
117
128
  const ownLevelFlags = getOwnLevelFlags(node);
118
129
  if (isLevelCounted && ownLevelFlags !== undefined) row[0] |= ownLevelFlags;
119
130
  const isInnerLevelCounted = isLevelCounted && ownLevelFlags === undefined;
120
131
  const name = getReferencedName(node);
132
+ // TLC's getLevelBound takes a parameter named like a variable for that variable.
133
+ if (name !== undefined && isLocallyResolved(node) && environment.variableIndex.has(name)) {
134
+ if (!isOperatorArgument) row[0] |= ABOVE_CONSTANT_BOUND;
135
+ if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
136
+ }
121
137
  if (name !== undefined && !isLocallyResolved(node)) {
122
138
  const target = environment.substitutions.get(name) ?? name;
123
139
  const definition = environment.definitions.get(target);
@@ -128,20 +144,30 @@ const collectLocalFacts = (
128
144
  environment.builtins.get(name)?.isStateLevel ||
129
145
  (definition && environment.variableIndex.has(definition.name))
130
146
  ) {
131
- row[0] |= NONCONSTANT;
147
+ row[0] |= nonconstantFlags;
132
148
  }
133
149
  if (variableIndex !== undefined) {
134
150
  if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
135
151
  if (!isOverridden) row[1 + (variableIndex >>> 5)] |= 1 << (variableIndex & 31);
136
152
  }
137
153
  if (definition) {
138
- edges.push({ callee: definition, isOverridden, isLevelCounted: isInnerLevelCounted });
154
+ edges.push({
155
+ callee: definition,
156
+ isOverridden,
157
+ isLevelCounted: isInnerLevelCounted,
158
+ isOperatorArgument:
159
+ isOperatorArgument ||
160
+ kind === "OperatorReference" ||
161
+ (kind === "Identifier" &&
162
+ definition.kind === "Operator" &&
163
+ definition.params.length > 0),
164
+ });
139
165
  } else {
140
- if (isImpureBuiltin(name, environment)) {
141
- row[0] |= IMPURE | (name === "Assert" ? 0 : REPEATED_EFFECT);
166
+ if (isImpureBuiltin(target, environment)) {
167
+ row[0] |= IMPURE | (target === "Assert" ? 0 : REPEATED_EFFECT);
142
168
  }
143
- if (STREAMED_BUILTINS.has(name)) row[0] |= STREAMED;
144
- if (RANDOM_BUILTINS.has(name)) row[0] |= RANDOM;
169
+ if (STREAMED_BUILTINS.has(target)) row[0] |= STREAMED;
170
+ if (RANDOM_BUILTINS.has(target)) row[0] |= RANDOM;
145
171
  if (!isOverridden && isImpureBuiltin(target, environment)) row[0] |= READS_IMPURE;
146
172
  const builtin = environment.builtins.get(target);
147
173
  if (
@@ -155,9 +181,11 @@ const collectLocalFacts = (
155
181
  }
156
182
  }
157
183
  }
158
- getChildren(node).forEach((child) => visit(child, isInnerLevelCounted));
184
+ getChildren(node).forEach((child) =>
185
+ visit(child, isInnerLevelCounted, isOperatorArgument || kind === "Lambda"),
186
+ );
159
187
  };
160
- expressions.forEach((expression) => visit(expression, true));
188
+ expressions.forEach((expression) => visit(expression, true, false));
161
189
  return { row, edges };
162
190
  };
163
191
 
@@ -230,9 +258,10 @@ const closeRows = (local: Uint32Array, words: number, edges: Int32Array[], mask:
230
258
 
231
259
  const PURITY_MASK = IMPURE | REPEATED_EFFECT | STREAMED | RANDOM;
232
260
  const READ_MASK = NONCONSTANT | READS_IMPURE;
261
+ const STARTUP_MASK = NONCONSTANT | ABOVE_CONSTANT_BOUND;
233
262
 
234
263
  const isEvaluatedOnce = (definition: Definition, flags: number) =>
235
- definition.kind === "Operator" && definition.params.length === 0 && (flags & NONCONSTANT) === 0;
264
+ definition.kind === "Operator" && definition.params.length === 0 && (flags & STARTUP_MASK) === 0;
236
265
 
237
266
  export const createDefinitionFacts = (environment: DefinitionNames): DefinitionFacts => {
238
267
  const definitions = [...new Set(environment.definitions.values())];
@@ -256,18 +285,32 @@ export const createDefinitionFacts = (environment: DefinitionNames): DefinitionF
256
285
  new Int32Array(own.filter((edge) => !edge.isOverridden && edge.isLevelCounted).map(getId)),
257
286
  );
258
287
  const levels = closeRows(local, words, levelEdges, TEMPORAL_LEVEL_FLAGS);
288
+ const startupEdges = edges.map(
289
+ (own) =>
290
+ new Int32Array(
291
+ own.filter((edge) => !edge.isOverridden && !edge.isOperatorArgument).map(getId),
292
+ ),
293
+ );
294
+ const startup = closeRows(local, words, startupEdges, ABOVE_CONSTANT_BOUND);
259
295
  const purityEdges = edges.map(
260
296
  (own) =>
261
297
  new Int32Array(
262
298
  own
263
299
  .map(getId)
264
- .filter((callee) => !isEvaluatedOnce(definitions[callee], reads[callee * words])),
300
+ .filter(
301
+ (callee) =>
302
+ !isEvaluatedOnce(
303
+ definitions[callee],
304
+ reads[callee * words] | startup[callee * words],
305
+ ),
306
+ ),
265
307
  ),
266
308
  );
267
309
  const purity = closeRows(localImpurity, words, purityEdges, PURITY_MASK);
268
310
  const rows = reads.map((word, position) =>
269
311
  position % words === 0
270
312
  ? (word & READ_MASK) |
313
+ (startup[position] & ABOVE_CONSTANT_BOUND) |
271
314
  (levels[position] & TEMPORAL_LEVEL_FLAGS) |
272
315
  (purity[position] & PURITY_MASK)
273
316
  : word,
@@ -291,6 +334,7 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
291
334
  const callee = getRow(edge.callee, environment);
292
335
  if (!edge.isOverridden) {
293
336
  row[0] |= callee[0] & READ_MASK;
337
+ if (!edge.isOperatorArgument) row[0] |= callee[0] & ABOVE_CONSTANT_BOUND;
294
338
  if (edge.isLevelCounted) row[0] |= callee[0] & TEMPORAL_LEVEL_FLAGS;
295
339
  for (let word = 1; word < words; word++) row[word] |= callee[word];
296
340
  }
@@ -300,7 +344,10 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
300
344
  };
301
345
 
302
346
  export const isConstantLevel = (definition: Definition, environment: Environment) =>
303
- (getRow(definition, environment)[0] & NONCONSTANT) === 0;
347
+ (getRow(definition, environment)[0] & STARTUP_MASK) === 0;
348
+
349
+ export const isEvaluatedAtStartup = (definition: Definition, environment: Environment) =>
350
+ (getRow(definition, environment)[0] & ABOVE_CONSTANT_BOUND) === 0;
304
351
 
305
352
  const EFFECT_FLAGS = {
306
353
  any: IMPURE,
@@ -308,6 +355,7 @@ const EFFECT_FLAGS = {
308
355
  streamed: STREAMED,
309
356
  // What a second evaluation shows: output again, or other random draws.
310
357
  replayed: REPEATED_EFFECT | RANDOM,
358
+ varying: IMPURE | RANDOM,
311
359
  };
312
360
 
313
361
  export const isExpressionImpure = (
package/src/dfid.ts CHANGED
@@ -15,7 +15,7 @@ import { EXIT_STATUS, getMessageExitStatus, withLivenessExitCode } from "./exit-
15
15
  import { createLivenessChecker } from "./liveness-checker";
16
16
  import { getIncompleteSuccessorMessage, prepareSearch, reportAssumptionViolation } from "./search";
17
17
  import type { SpecAction } from "./spec-description";
18
- import { forEachInitialState, forEachSuccessor } from "./successors";
18
+ import { forEachInitialState, forEachSuccessor, getSuccessors } from "./successors";
19
19
  import {
20
20
  formatNestedMessage,
21
21
  formatTlcDate,
@@ -28,7 +28,7 @@ import {
28
28
  import { getTlcFingerprint } from "./tlc/fingerprint";
29
29
  import { replaySuccessors } from "./tlc/replay";
30
30
  import { getOptimisticProbability, getActualProbability } from "./tlc/summary";
31
- import { createModelValue, formatState, getSetBound, type Value } from "./values";
31
+ import { createModelValue, formatState, getSetBound, isSameValue, type Value } from "./values";
32
32
 
33
33
  export interface DepthFirstOptions extends CheckOptions {
34
34
  maxDepth: number;
@@ -131,7 +131,7 @@ export const checkDepthFirst = (options: DepthFirstOptions): number => {
131
131
  withUnexpectedException(() =>
132
132
  createLivenessChecker(temporalProperties, search.spec.temporals, environment, {
133
133
  getFingerprint: () => 0,
134
- getSuccessors: () => [],
134
+ forEachActionSuccessors: () => {},
135
135
  }),
136
136
  ),
137
137
  )?.branches;
@@ -165,6 +165,13 @@ export const checkDepthFirst = (options: DepthFirstOptions): number => {
165
165
  if (assumptionStatus !== undefined) return assumptionStatus;
166
166
 
167
167
  const nextActions = prepared.getDescription().actions;
168
+ // Deviation from TLC: TLCExt#pickSuccessor casts the DFID checker to ModelChecker and fails, so tla-ts asks as model checking does.
169
+ runtime.getSuccessorAction = (state, next) =>
170
+ nextActions.find((action) =>
171
+ getSuccessors(action.expression, state, environment, action.scope).some((successor) =>
172
+ successor.state.every((value, index) => isSameValue(value, next[index])),
173
+ ),
174
+ );
168
175
  const statuses = new Map<bigint, number>();
169
176
  const fingerprintSet = { level: 1, leveled: 0, buckets: INITIAL_BUCKETS };
170
177
  const setStatus = (fingerprint: bigint, status: number) => {
@@ -261,16 +268,21 @@ export const checkDepthFirst = (options: DepthFirstOptions): number => {
261
268
  config.alias === undefined
262
269
  ? search.toRecord(state)
263
270
  : search.evaluateAlias(config.alias, state, state, isTool);
264
- const violated = isContinued
265
- ? search.getViolatedInvariants(state)
266
- : [search.findViolatedInvariant(state)].filter((invariant) => invariant !== undefined);
267
- for (const invariant of violated) {
271
+ const reportInvariant = (name: string) =>
268
272
  message(
269
273
  MESSAGE_CODE.invariantViolatedInitial,
270
- `Invariant ${invariant.name} is violated by the initial state:\n${formatState(alias())}`,
274
+ `Invariant ${name} is violated by the initial state:\n${formatState(alias())}`,
271
275
  );
272
- if (!isContinued) return MESSAGE_CODE.invariantViolatedInitial;
273
- checker.continuedCode = MESSAGE_CODE.invariantViolatedInitial;
276
+ if (isContinued) {
277
+ search.forEachViolatedInvariant(state, (invariant) => {
278
+ reportInvariant(invariant.name);
279
+ checker.continuedCode = MESSAGE_CODE.invariantViolatedInitial;
280
+ });
281
+ }
282
+ const violated = isContinued ? undefined : search.findViolatedInvariant(state);
283
+ if (violated) {
284
+ reportInvariant(violated.name);
285
+ return MESSAGE_CODE.invariantViolatedInitial;
274
286
  }
275
287
  const predicate = search.findFailedInitialPredicate(state);
276
288
  if (predicate) {
@@ -9,6 +9,7 @@ import {
9
9
  type Instance,
10
10
  type Module,
11
11
  type OperatorParam,
12
+ type Proof,
12
13
  type SourceLocation,
13
14
  } from "./ast";
14
15
  import type { ModuleOperator } from "./check";
@@ -105,7 +106,6 @@ interface EnvironmentOptions {
105
106
 
106
107
  export interface RuntimeInvariant {
107
108
  name: string;
108
- /** Undefined when the invariant names a definition of the root module. */
109
109
  module: string | undefined;
110
110
  }
111
111
 
@@ -237,6 +237,19 @@ const getSubstitutions = (instances: Instance[]) =>
237
237
  instance.substitutions.map((substitution) => substitution.expression),
238
238
  );
239
239
 
240
+ const getProofInstances = (proof: Proof | undefined): Instance[] =>
241
+ proof?.kind === "Steps"
242
+ ? proof.steps.flatMap((step) => [
243
+ ...(step.body.kind === "Instance" ? [step.body] : []),
244
+ ...(step.body.kind === "Define"
245
+ ? step.body.definitions.flatMap((definition) =>
246
+ definition.kind === "Instance" ? [definition] : [],
247
+ )
248
+ : []),
249
+ ...getProofInstances(step.proof),
250
+ ])
251
+ : [];
252
+
240
253
  const rejectLiterals = (expressions: Expression[]): void =>
241
254
  expressions.forEach((expression) => {
242
255
  if (expression.kind === "Decimal") throw createRealNumberError(expression);
@@ -276,9 +289,10 @@ export const createEnvironment = (
276
289
  const dependencies = new Map<string, Set<string>>();
277
290
  const loading: Set<string>[] = [];
278
291
  const linking: string[] = [];
292
+ const usedModules = new Set<string>();
279
293
 
280
294
  const useModule = (name: string, used: Iterable<string>) =>
281
- loading.forEach((closure) => {
295
+ [usedModules, ...loading].forEach((closure) => {
282
296
  closure.add(name);
283
297
  [...used].forEach((dependency) => closure.add(dependency));
284
298
  });
@@ -506,7 +520,7 @@ export const createEnvironment = (
506
520
  const instantiation = createInstantiation({
507
521
  params,
508
522
  substitutions: new Map(
509
- [...substitutions].map(([name, expression]) => [name, renameLocals(expression, renamed)]),
523
+ [...substitutions].map((entry) => [entry[0], renameLocals(entry[1], renamed)]),
510
524
  ),
511
525
  variables: new Set(linked.variables),
512
526
  getDefinition: (key) => definitions.get(key),
@@ -549,9 +563,14 @@ export const createEnvironment = (
549
563
  instance.name === undefined
550
564
  ? standardSymbols
551
565
  : new Map(
552
- [...standardSymbols].map(([name, symbol]) => [
553
- `${instance.name}!${name}`,
554
- { key: symbol.key, arity: symbol.arity, params: symbol.params, kind: symbol.kind },
566
+ [...standardSymbols].map((entry) => [
567
+ `${instance.name}!${entry[0]}`,
568
+ {
569
+ key: entry[1].key,
570
+ arity: entry[1].arity,
571
+ params: entry[1].params,
572
+ kind: entry[1].kind,
573
+ },
555
574
  ]),
556
575
  );
557
576
 
@@ -564,32 +583,34 @@ export const createEnvironment = (
564
583
  const declared = new Set(declarations.map((declaration) => declaration.name));
565
584
  return new Map(
566
585
  [...exported]
567
- .filter(([name]) => !declared.has(name))
568
- .map(([name, symbol]): [string, ModuleSymbol] => {
586
+ .filter((entry) => !declared.has(entry[0]))
587
+ .map((entry): [string, ModuleSymbol] => {
569
588
  if (instance.name === undefined) {
570
589
  return [
571
- name,
590
+ entry[0],
572
591
  {
573
- key: getKey(symbol.key, name),
574
- arity: symbol.arity,
575
- params: symbol.params,
576
- kind: symbol.kind,
592
+ key: getKey(entry[1].key, entry[0]),
593
+ arity: entry[1].arity,
594
+ params: entry[1].params,
595
+ kind: entry[1].kind,
577
596
  range:
578
- parameterized.get(symbol.key) === true ? instance.location.range : symbol.range,
597
+ parameterized.get(entry[1].key) === true
598
+ ? instance.location.range
599
+ : entry[1].range,
579
600
  },
580
601
  ];
581
602
  }
582
- const qualified = `${instance.name}!${name}`;
603
+ const qualified = `${instance.name}!${entry[0]}`;
583
604
  return [
584
605
  qualified,
585
606
  {
586
- key: getKey(symbol.key, qualified),
587
- arity: symbol.arity + instance.params.length,
588
- params: symbol.params && [
607
+ key: getKey(entry[1].key, qualified),
608
+ arity: entry[1].arity + instance.params.length,
609
+ params: entry[1].params && [
589
610
  ...instance.params.map((param) => param.arity),
590
- ...symbol.params,
611
+ ...entry[1].params,
591
612
  ],
592
- kind: symbol.kind,
613
+ kind: entry[1].kind,
593
614
  },
594
615
  ];
595
616
  }),
@@ -637,11 +658,11 @@ export const createEnvironment = (
637
658
  const standardSymbols = nested ? undefined : getStandardSymbols(instance.module);
638
659
  if (standardSymbols) {
639
660
  if (instance.name === undefined) return [];
640
- return [...standardSymbols].map(([name, symbol]) => {
641
- const forwarded = createArgumentParams(symbol.arity, symbol.params);
661
+ return [...standardSymbols].map((entry) => {
662
+ const forwarded = createArgumentParams(entry[1].arity, entry[1].params);
642
663
  return createLocalAlias(
643
- `${instance.name}!${name}`,
644
- symbol.key,
664
+ `${instance.name}!${entry[0]}`,
665
+ entry[1].key,
645
666
  [...instance.params, ...forwarded],
646
667
  forwarded,
647
668
  location,
@@ -722,16 +743,16 @@ export const createEnvironment = (
722
743
  });
723
744
  const declared = new Set(declarations.map((declaration) => declaration.name));
724
745
  const aliases = [...linked.exported]
725
- .filter(([name]) => !declared.has(name))
726
- .map(([name, symbol]) => {
727
- const key = instantiation.getKey(symbol.key);
728
- const ownParams = createArgumentParams(symbol.arity, symbol.params);
746
+ .filter((entry) => !declared.has(entry[0]))
747
+ .map((entry) => {
748
+ const key = instantiation.getKey(entry[1].key);
749
+ const ownParams = createArgumentParams(entry[1].arity, entry[1].params);
729
750
  const params = [...instance.params, ...ownParams];
730
751
  return createLocalAlias(
731
- instance.name === undefined ? name : `${instance.name}!${name}`,
752
+ instance.name === undefined ? entry[0] : `${instance.name}!${entry[0]}`,
732
753
  key,
733
754
  params,
734
- key === symbol.key ? ownParams : params,
755
+ key === entry[1].key ? ownParams : params,
735
756
  location,
736
757
  );
737
758
  });
@@ -739,9 +760,9 @@ export const createEnvironment = (
739
760
  };
740
761
 
741
762
  const getAvailableDefinitions = (visible: Symbols) =>
742
- [...visible].flatMap(([name, symbol]) => {
743
- const definition = definitions.get(symbol.key);
744
- return definition ? [{ ...definition, name }] : [];
763
+ [...visible].flatMap((entry) => {
764
+ const definition = definitions.get(entry[1].key);
765
+ return definition ? [{ ...definition, name: entry[0] }] : [];
745
766
  });
746
767
 
747
768
  const javaOverrides = new Map<string, JavaOverride[]>();
@@ -890,6 +911,13 @@ export const createEnvironment = (
890
911
  module.definitions.toReversed().map((definition) => [definition.name, definition]),
891
912
  ),
892
913
  getKey,
914
+ isModuleKnown: (name, location) =>
915
+ name === parsed.name ||
916
+ usedModules.has(name) ||
917
+ scope.modules.has(name) ||
918
+ parsed.modules.some(
919
+ (nested) => nested.name === name && isBefore(nested.location, location),
920
+ ),
893
921
  instanced,
894
922
  facts,
895
923
  reports,
@@ -910,7 +938,7 @@ export const createEnvironment = (
910
938
  getDefinitionSymbol(definition),
911
939
  ]),
912
940
  ].reduce(
913
- (symbols, [name, symbol]) => (symbols.has(name) ? symbols : symbols.set(name, symbol)),
941
+ (symbols, entry) => (symbols.has(entry[0]) ? symbols : symbols.set(entry[0], entry[1])),
914
942
  new Map(visible),
915
943
  );
916
944
  const linkNested = (nested: Module) => {
@@ -966,6 +994,13 @@ export const createEnvironment = (
966
994
  ),
967
995
  getAvailableDefinitions(visible),
968
996
  );
997
+ parsed.theorems
998
+ .flatMap((theorem) => getProofInstances(theorem.proof))
999
+ .filter((instance) => !getVisibleModules().has(instance.module))
1000
+ .forEach(
1001
+ (instance) =>
1002
+ getStandardSymbols(instance.module) ?? getLinkedModule(instance.module, parsed.name),
1003
+ );
969
1004
  scope.errors.push(...resolveModule(module, getUnit(module)));
970
1005
  module.definitions.forEach((definition) => {
971
1006
  const key = getKey(definition);
@@ -1074,7 +1109,7 @@ export const createEnvironment = (
1074
1109
  root: linkedRoot,
1075
1110
  moduleSymbols: new Map([
1076
1111
  ...standardExports,
1077
- ...[...linkedModules].map(([name, linked]): [string, Symbols] => [name, linked.visible]),
1112
+ ...[...linkedModules].map((entry): [string, Symbols] => [entry[0], entry[1].visible]),
1078
1113
  [root.name, linkedRoot.visible],
1079
1114
  ]),
1080
1115
  definitions,
@@ -1125,6 +1160,7 @@ export const createEnvironment = (
1125
1160
  variableIndex,
1126
1161
  facts,
1127
1162
  startupValues: Array.from({ length: facts.ids.size }, (): Value | undefined => undefined),
1163
+ tlcEvalValues: new WeakMap(),
1128
1164
  substitutedDefinitions,
1129
1165
  instanceParams,
1130
1166
  evaluators: new WeakMap(),
package/src/errors.ts CHANGED
@@ -320,6 +320,13 @@ export class SmtTacticError extends TlaError {
320
320
  }
321
321
  }
322
322
 
323
+ export class SmtDefaultError extends TlaError {
324
+ constructor(message: string) {
325
+ super(message);
326
+ this.name = "SmtDefaultError";
327
+ }
328
+ }
329
+
323
330
  export class SmtInvariantError extends TlaError {
324
331
  constructor(message: string) {
325
332
  super(message);