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
@@ -51,6 +51,11 @@ export interface LivenessChecker {
51
51
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
52
52
  }
53
53
 
54
+ export interface LivenessChecks {
55
+ solutions: Solution[];
56
+ createChecker: (search: SearchGraph<Value[]>, solutions: Solution[]) => LivenessChecker;
57
+ }
58
+
54
59
  export interface LiveGraph<State> {
55
60
  branches: number;
56
61
  addInitialState: (index: number, state: State) => void;
@@ -59,16 +64,20 @@ export interface LiveGraph<State> {
59
64
  index: number,
60
65
  state: State,
61
66
  successors: LiveSuccessor<State>[],
67
+ isRerun?: boolean,
62
68
  ) => number[] | undefined;
63
69
  storeState: (pending: number, index: number) => void;
64
- // How many states the graph of each branch has, which TLC counts as the fingerprints of its nodes.
65
70
  getStateCounts: () => number[];
66
71
  findViolation: () => Lasso | undefined;
67
72
  }
68
73
 
69
74
  export interface SearchGraph<State> {
70
75
  getFingerprint: (successor: LiveSuccessor<State>) => number;
71
- getSuccessors: (index: number, state: State) => LiveSuccessor<State>[];
76
+ forEachActionSuccessors: (
77
+ index: number,
78
+ state: State,
79
+ onSuccessors: (successors: LiveSuccessor<State>[]) => void,
80
+ ) => void;
72
81
  }
73
82
 
74
83
  export interface LiveEvaluation<State> {
@@ -313,12 +322,11 @@ export const getLiveExpressions = (solutions: Solution[]) =>
313
322
  getAtomExpressions(atom).map((item) => item.expression),
314
323
  );
315
324
 
316
- export const createLivenessChecker = (
325
+ export const createLivenessChecks = (
317
326
  properties: TemporalProperty[],
318
327
  temporals: ScopedExpression[],
319
328
  environment: Environment,
320
- search: SearchGraph<Value[]>,
321
- ): LivenessChecker | undefined => {
329
+ ): LivenessChecks | undefined => {
322
330
  if (properties.length === 0) return undefined;
323
331
  const live = getLiveFormula(properties, temporals, environment);
324
332
  // A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
@@ -333,61 +341,75 @@ export const createLivenessChecker = (
333
341
  "repeated",
334
342
  )
335
343
  : !hasRepeatedEffects(environment);
336
- const tracing = { environment, atoms: getInterpretedAtoms(environment) };
337
- const solutions = getSolutions(live.formula);
338
- const graph = createLiveGraph(
339
- solutions,
340
- {
341
- atoms: {
342
- holdsState: (atom, state) => tracing.atoms.holdsState(atom, state),
343
- holdsAction: (atom, state, next) => tracing.atoms.holdsAction(atom, state, next),
344
- },
345
- isShared,
346
- isSame: isSameState,
347
- evaluateFrom: (source, evaluate) => {
348
- environment.runtime.setLivenessSource(source);
344
+ return {
345
+ solutions: getSolutions(live.formula),
346
+ createChecker: (search, solutions) => {
347
+ const tracing = { environment, atoms: getInterpretedAtoms(environment) };
348
+ const graph = createLiveGraph(
349
+ solutions,
350
+ {
351
+ atoms: {
352
+ holdsState: (atom, state) => tracing.atoms.holdsState(atom, state),
353
+ holdsAction: (atom, state, next) => tracing.atoms.holdsAction(atom, state, next),
354
+ },
355
+ isShared,
356
+ isSame: isSameState,
357
+ evaluateFrom: (source, evaluate) => {
358
+ environment.runtime.setLivenessSource(source);
359
+ try {
360
+ return evaluate();
361
+ } finally {
362
+ environment.runtime.setLivenessSource(undefined);
363
+ }
364
+ },
365
+ },
366
+ search,
367
+ environment.runtime.version !== "1.7.4",
368
+ );
369
+ const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
370
+ if (replay === undefined) return run();
371
+ tracing.atoms = getInterpretedAtoms(replay);
349
372
  try {
350
- return evaluate();
373
+ return run();
351
374
  } finally {
352
- environment.runtime.setLivenessSource(undefined);
375
+ tracing.atoms = getInterpretedAtoms(environment);
353
376
  }
354
- },
377
+ };
378
+ return {
379
+ branches: graph.branches,
380
+ solutions,
381
+ addInitialState: (index, state, replay) =>
382
+ traceWith(replay, () => graph.addInitialState(index, state)),
383
+ addState: (index, state, successors, replay) =>
384
+ traceWith(replay, () => graph.addState(index, state, successors, replay !== undefined)),
385
+ storeState: graph.storeState,
386
+ getStateCounts: graph.getStateCounts,
387
+ findViolation: graph.findViolation,
388
+ getViolatedProperties: (path, cycleStart) => [
389
+ ...new Set(
390
+ properties
391
+ .filter(
392
+ (_property, position) =>
393
+ !evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
394
+ )
395
+ .map((property) => property.name),
396
+ ),
397
+ ],
398
+ };
355
399
  },
356
- search,
357
- environment.runtime.version !== "1.7.4",
358
- );
359
- const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
360
- if (replay === undefined) return run();
361
- tracing.atoms = getInterpretedAtoms(replay);
362
- try {
363
- return run();
364
- } finally {
365
- tracing.atoms = getInterpretedAtoms(environment);
366
- }
367
- };
368
- return {
369
- branches: graph.branches,
370
- solutions,
371
- addInitialState: (index, state, replay) =>
372
- traceWith(replay, () => graph.addInitialState(index, state)),
373
- addState: (index, state, successors, replay) =>
374
- traceWith(replay, () => graph.addState(index, state, successors)),
375
- storeState: graph.storeState,
376
- getStateCounts: graph.getStateCounts,
377
- findViolation: graph.findViolation,
378
- getViolatedProperties: (path, cycleStart) => [
379
- ...new Set(
380
- properties
381
- .filter(
382
- (_property, position) =>
383
- !evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
384
- )
385
- .map((property) => property.name),
386
- ),
387
- ],
388
400
  };
389
401
  };
390
402
 
403
+ export const createLivenessChecker = (
404
+ properties: TemporalProperty[],
405
+ temporals: ScopedExpression[],
406
+ environment: Environment,
407
+ search: SearchGraph<Value[]>,
408
+ ): LivenessChecker | undefined => {
409
+ const checks = createLivenessChecks(properties, temporals, environment);
410
+ return checks?.createChecker(search, checks.solutions);
411
+ };
412
+
391
413
  export const createLiveGraph = <State>(
392
414
  solutions: Solution[],
393
415
  evaluation: LiveEvaluation<State>,
@@ -637,7 +659,6 @@ export const createLiveGraph = <State>(
637
659
  writeToPool(behavior.lastNodes, state, [node]);
638
660
  return node;
639
661
  };
640
- // TLC's table of tableau nodes has a state once the search expands it or it has a node.
641
662
  const hasState = (behavior: BehaviorGraph<State>, state: number) =>
642
663
  state < 0
643
664
  ? behavior.checks.nodes.some(
@@ -756,39 +777,57 @@ export const createLiveGraph = <State>(
756
777
  actions.push(0);
757
778
  if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
758
779
  }
759
- const nextStates = search.getSuccessors(index, state);
760
780
  // The results of the step to the state itself come first, then those of each successor.
761
- const actionResults = new Uint8Array((nextStates.length + 1) * actionCount);
762
- actionResults.set(selfResults);
763
- const edges = createEdgeRows(nextStates.length);
764
- nextStates.forEach((successor, position) => {
765
- const successorRow = createRows(1);
766
- checkAction(
767
- behavior,
768
- index,
769
- state,
770
- row,
771
- offset,
772
- successor.state,
773
- edges,
774
- position * actionIds.size,
775
- actionResults,
776
- (position + 1) * actionCount,
777
- );
778
- const isDone = behavior.isDone[successor.index] === true;
779
- for (const next of tableauNode.successors) {
780
- if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
781
- const existing = getNodeId(behavior, successor.index, next);
782
- if (existing !== undefined && successors.includes(existing)) continue;
783
- const target = existing ?? recordNode(behavior, successor.index, next);
784
- successors.push(target);
785
- actions.push(position + 1);
786
- if (existing === undefined && isDone) {
787
- expandLate(behavior, tableau, successor.state, successor.index, target, successorRow, 0);
781
+ const actionBatches = [selfResults];
782
+ let stepCount = 1;
783
+ search.forEachActionSuccessors(index, state, (nextStates) => {
784
+ const edges = createEdgeRows(nextStates.length);
785
+ const results = new Uint8Array(nextStates.length * actionCount);
786
+ actionBatches.push(results);
787
+ for (let position = 0; position < nextStates.length; position++) {
788
+ const successor = nextStates[position];
789
+ const successorRow = createRows(1);
790
+ checkAction(
791
+ behavior,
792
+ index,
793
+ state,
794
+ row,
795
+ offset,
796
+ successor.state,
797
+ edges,
798
+ position * actionIds.size,
799
+ results,
800
+ position * actionCount,
801
+ );
802
+ const isDone = behavior.isDone[successor.index] === true;
803
+ for (const next of tableauNode.successors) {
804
+ if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
805
+ const existing = getNodeId(behavior, successor.index, next);
806
+ if (existing !== undefined && successors.includes(existing)) continue;
807
+ const target = existing ?? recordNode(behavior, successor.index, next);
808
+ successors.push(target);
809
+ actions.push(stepCount + position);
810
+ if (existing === undefined && isDone) {
811
+ expandLate(
812
+ behavior,
813
+ tableau,
814
+ successor.state,
815
+ successor.index,
816
+ target,
817
+ successorRow,
818
+ 0,
819
+ );
820
+ }
788
821
  }
789
822
  }
823
+ stepCount += nextStates.length;
790
824
  });
791
825
  if (successors.length > 0) {
826
+ const actionResults = new Uint8Array(stepCount * actionCount);
827
+ for (let batch = 0, resultOffset = 0; batch < actionBatches.length; batch++) {
828
+ actionResults.set(actionBatches[batch], resultOffset);
829
+ resultOffset += actionBatches[batch].length;
830
+ }
792
831
  writeNode(behavior, node, successors, actionResults, actions, stateResults);
793
832
  }
794
833
  };
@@ -1143,7 +1182,7 @@ export const createLiveGraph = <State>(
1143
1182
  }
1144
1183
  }
1145
1184
  },
1146
- addState: (index, state, successors) => {
1185
+ addState: (index, state, successors, isRerun) => {
1147
1186
  const set = getSuccessorSet(index, state, successors);
1148
1187
  const rows = createRows(set.length);
1149
1188
  // The set holds the state itself, as a successor of the same index.
@@ -1168,6 +1207,15 @@ export const createLiveGraph = <State>(
1168
1207
  );
1169
1208
  const stateResults = checkState(behavior, index, state, rows, offset);
1170
1209
  const tableau = behavior.solution.tableau;
1210
+ // TLC's rerun for a call stack fails an assertion, without a call stack, on a branch that has every edge of the state.
1211
+ if (
1212
+ isRerun &&
1213
+ (tableau
1214
+ ? getStateNodes(behavior, index).some((node) => behavior.edgeCounts[node] > 0)
1215
+ : set.every((successor) => isWritten(behavior, successor.index)))
1216
+ ) {
1217
+ throw new TlaEvaluationError("The behavior graph holds every edge of the state already.");
1218
+ }
1171
1219
  if (!tableau) {
1172
1220
  addPlainState(behavior, set, actionResults, stateResults, index);
1173
1221
  continue;
package/src/liveness.ts CHANGED
@@ -16,6 +16,7 @@ import {
16
16
  forEachBoundElement,
17
17
  getBoundElements,
18
18
  getDefinition,
19
+ getReevaluatedDefinitions,
19
20
  getStartupValue,
20
21
  lookupScope,
21
22
  resolveApplyOperator,
@@ -243,6 +244,7 @@ export const expandTemporal = (
243
244
  return expression.operands.flatMap((operand) => expand(operand, scope, describeRange(operand)));
244
245
  }
245
246
  if (expression.kind === "Label") return expand(expression.body, scope);
247
+ if (expression.kind === "Selection") return expand(expression.expression, scope);
246
248
  if (expression.kind === "Let") {
247
249
  return expand(expression.body, bindLetDefinitions(expression, scope, environment));
248
250
  }
@@ -323,12 +325,17 @@ export const expandTemporal = (
323
325
  return [{ expression, scope, name: expansion.name, path: expansion.path }];
324
326
  };
325
327
 
326
- const bindLetDefinitions = (
328
+ // TLC takes a formula apart through a LET without binding its definitions, so it evaluates an impure one again at each reference.
329
+ export const bindLetDefinitions = (
327
330
  expression: Expression & { kind: "Let" },
328
331
  scope: Scope | undefined,
329
332
  environment: Environment,
330
333
  ) => {
331
- const bound = bindDefinitions(expression.definitions, getConstantContext(environment, scope));
334
+ const bound = bindDefinitions(
335
+ expression.definitions,
336
+ getConstantContext(environment, scope),
337
+ getReevaluatedDefinitions(expression.definitions, environment),
338
+ );
332
339
  for (let current = bound; current && current !== scope; current = current.parent) {
333
340
  if (current.binding.kind === "Thunk") definitionThunks.add(current.binding);
334
341
  }
@@ -488,12 +495,53 @@ export const toLiveExpression = (
488
495
  return level > ACTION_LEVEL ? parts : toAtom(expression, scope, level);
489
496
  };
490
497
 
498
+ // SANY parses `a /\ b /\ c` as `(a /\ b) /\ c`, so TLC takes a prefix below the temporal level as one formula.
499
+ const convertJunction = (
500
+ expression: Expression & { kind: "And" | "Or" },
501
+ scope: Scope | undefined,
502
+ ) => {
503
+ const operands = expression.operands;
504
+ const range = expression.location.range;
505
+ const prefixEnds = expression.prefixEnds;
506
+ if (expression.isBulleted || !range || !prefixEnds) {
507
+ return toWhole(
508
+ expression,
509
+ scope,
510
+ createJunction(
511
+ expression.kind,
512
+ operands.map((operand) => convert(operand, scope)),
513
+ ),
514
+ );
515
+ }
516
+ return operands.slice(1).reduce(
517
+ (prefix, operand, index) => {
518
+ const node =
519
+ index === operands.length - 2
520
+ ? expression
521
+ : {
522
+ ...expression,
523
+ operands: operands.slice(0, index + 2),
524
+ prefixEnds: prefixEnds.slice(0, index + 1),
525
+ location: { ...expression.location, range: { ...range, end: prefixEnds[index] } },
526
+ };
527
+ return toWhole(
528
+ node,
529
+ scope,
530
+ createJunction(expression.kind, [prefix, convert(operand, scope)]),
531
+ );
532
+ },
533
+ convert(operands[0], scope),
534
+ );
535
+ };
536
+
491
537
  // These forms are translated part by part at every level; any other form below the temporal level is an atom.
492
538
  const convert = (expression: Expression, scope: Scope | undefined): LiveExpression => {
493
539
  const level = getLevel(expression, scope, environment);
494
540
  switch (expression.kind) {
495
541
  case "Label":
496
542
  return convert(expression.body, scope);
543
+ case "Selection":
544
+ return convert(expression.expression, scope);
497
545
  case "Let":
498
546
  return convert(expression.body, bindLetDefinitions(expression, scope, environment));
499
547
  case "Apply": {
@@ -512,14 +560,7 @@ export const toLiveExpression = (
512
560
  }
513
561
  case "And":
514
562
  case "Or":
515
- return toWhole(
516
- expression,
517
- scope,
518
- createJunction(
519
- expression.kind,
520
- expression.operands.map((operand) => convert(operand, scope)),
521
- ),
522
- );
563
+ return convertJunction(expression, scope);
523
564
  case "Forall":
524
565
  case "Exists":
525
566
  return convertQuantifier(expression, scope);
@@ -636,7 +677,7 @@ export const getInterpretedAtoms = (environment: Environment): LiveAtoms<Value[]
636
677
  },
637
678
  });
638
679
 
639
- export const evaluateLive = <State>(
680
+ const evaluateLive = <State>(
640
681
  expression: LiveExpression,
641
682
  state: State,
642
683
  next: State | undefined,
@@ -179,7 +179,7 @@ const loadMule = (
179
179
 
180
180
  const schedule = (modules: Map<string, Mule>) => {
181
181
  const dependencies = new Map(
182
- [...modules].map(([name, module]) => [name, getDependencies(module).dependencies]),
182
+ [...modules].map((entry) => [entry[0], getDependencies(entry[1]).dependencies]),
183
183
  );
184
184
  const seen = new Set<string>();
185
185
  const order: Mule[] = [];
@@ -351,10 +351,7 @@ const instantiate = (
351
351
  substitutes.set(name, at({ kind: "Opaque", name }, { location }));
352
352
  }
353
353
  const anonymized = new Map(
354
- [...substitutes].map(([name, expression]) => [
355
- name,
356
- pipeline.anonymizer.expr(instanceScope, expression),
357
- ]),
354
+ [...substitutes].map((entry) => [entry[0], pipeline.anonymizer.expr(instanceScope, entry[1])]),
358
355
  );
359
356
  const body = substituteUnits(
360
357
  shift((instanceScope?.size ?? 0) - (module.depth ?? 0)),
@@ -430,26 +430,26 @@ const createPrinter = (hyps: Hyp[] = [], options: PrinterOptions = {}) => {
430
430
  );
431
431
  case "Choose": {
432
432
  const domainDoc = expression.domain && printExpr(expression.domain);
433
- return withNames(context, [expression.name], ([name]) =>
433
+ return withNames(context, [expression.name], (names) =>
434
434
  createBig(
435
435
  domainDoc
436
436
  ? format(
437
437
  "@[<b2>CHOOSE @[<b2>%s \\in@ %a@] :@ %a@]",
438
- name,
438
+ names[0],
439
439
  domainDoc,
440
440
  printExpr(expression.body),
441
441
  )
442
- : format("@[<b2>CHOOSE %s :@ %a@]", name, printExpr(expression.body)),
442
+ : format("@[<b2>CHOOSE %s :@ %a@]", names[0], printExpr(expression.body)),
443
443
  ),
444
444
  );
445
445
  }
446
446
  case "SetSt": {
447
447
  const domainDoc = printExpr(expression.domain);
448
- return withNames(context, [expression.name], ([name]) =>
448
+ return withNames(context, [expression.name], (names) =>
449
449
  createAtom(
450
450
  format(
451
451
  "@[<b3>{@[<b2>%s \\in@ %a@] :@ %a}@]",
452
- name,
452
+ names[0],
453
453
  domainDoc,
454
454
  printExpr(expression.body),
455
455
  ),
@@ -643,6 +643,8 @@ export const createModuleConverter = (
643
643
  },
644
644
  { location },
645
645
  );
646
+ case "Selection":
647
+ return recurse(expression.expression);
646
648
  case "Subexpression": {
647
649
  const [head, ...selectors] = expression.selectors;
648
650
  if (head.kind !== "Name") throw new TlaProofError("Unexpected subexpression reference");