tla-ts 0.0.9 → 0.0.10-dev.28c823e4b

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 (390) hide show
  1. package/README.md +29 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +28 -28
  5. package/dist/deciders.js +43 -43
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +106 -10
  8. package/dist/index.d.ts +106 -10
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +116 -36
  15. package/dist/prove.js +116 -36
  16. package/dist/run.cjs +143 -31
  17. package/dist/run.js +143 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +129 -104
  21. package/dist/transfer.js +129 -104
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +3 -1
  25. package/src/ast.ts +4 -23
  26. package/src/bags.ts +99 -102
  27. package/src/builtins.ts +40 -78
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check.ts +599 -388
  30. package/src/cli/options.ts +11 -6
  31. package/src/cli/run.ts +0 -2
  32. package/src/cli/runtime-invariants.ts +136 -0
  33. package/src/cli/shared.ts +18 -11
  34. package/src/cli/tlapm.ts +0 -12
  35. package/src/cli/tlc-arguments.ts +640 -0
  36. package/src/cli/tlc-usage.ts +361 -0
  37. package/src/cli/tlc.ts +538 -220
  38. package/src/cli/typescript.ts +23 -0
  39. package/src/cli/xml-exporter.ts +4 -16
  40. package/src/cli.ts +0 -1
  41. package/src/codegen.ts +191 -64
  42. package/src/config.ts +140 -109
  43. package/src/coverage.ts +837 -0
  44. package/src/dependencies.ts +6 -40
  45. package/src/dfid.ts +618 -0
  46. package/src/environment.ts +240 -118
  47. package/src/errors.ts +70 -55
  48. package/src/evaluate.ts +596 -339
  49. package/src/exit-codes.ts +37 -3
  50. package/src/fingerprints.ts +10 -10
  51. package/src/index.ts +3 -0
  52. package/src/instances.ts +79 -11
  53. package/src/java-overrides.ts +4 -19
  54. package/src/json-reader.ts +455 -0
  55. package/src/json.ts +255 -139
  56. package/src/levels.ts +8 -17
  57. package/src/lexer.ts +80 -100
  58. package/src/liveness-checker.ts +82 -119
  59. package/src/liveness.ts +112 -64
  60. package/src/obligations/action.ts +4 -28
  61. package/src/obligations/anonymize.ts +84 -80
  62. package/src/obligations/equality.ts +1 -1
  63. package/src/obligations/expression.ts +2 -19
  64. package/src/obligations/format.ts +1 -9
  65. package/src/obligations/generate.ts +1 -11
  66. package/src/obligations/index.ts +0 -11
  67. package/src/obligations/levels.ts +4 -8
  68. package/src/obligations/module.ts +1 -15
  69. package/src/obligations/normalize.ts +5 -24
  70. package/src/obligations/operators.ts +1 -2
  71. package/src/obligations/pragma.ts +1 -10
  72. package/src/obligations/printer.ts +47 -46
  73. package/src/obligations/proof.ts +1 -5
  74. package/src/obligations/regroup.ts +1 -4
  75. package/src/obligations/simplify.ts +3 -14
  76. package/src/obligations/source.ts +1 -21
  77. package/src/obligations/subexpression.ts +5 -11
  78. package/src/obligations/substitution.ts +1 -3
  79. package/src/obligations/temporal.ts +8 -14
  80. package/src/obligations/tuples.ts +3 -9
  81. package/src/parallel-worker.ts +29 -39
  82. package/src/parallel.ts +53 -44
  83. package/src/parser.ts +565 -282
  84. package/src/pcal/ast.ts +53 -86
  85. package/src/pcal/parse.ts +144 -219
  86. package/src/pcal/tokenize.ts +91 -131
  87. package/src/pcal/translate.ts +83 -130
  88. package/src/pcal/validate.ts +48 -68
  89. package/src/pretty-print.ts +7 -8
  90. package/src/prover/decide-pool.ts +5 -10
  91. package/src/prover/deciders.ts +0 -4
  92. package/src/prover/first-order.ts +0 -11
  93. package/src/prover/isabelle/decide.ts +0 -6
  94. package/src/prover/isabelle/encode.ts +11 -23
  95. package/src/prover/isabelle/isar/inner-syntax.ts +108 -114
  96. package/src/prover/isabelle/isar/method.ts +25 -38
  97. package/src/prover/isabelle/isar/proof.ts +1 -10
  98. package/src/prover/isabelle/isar/statement.ts +1 -6
  99. package/src/prover/isabelle/isar/theory.ts +15 -26
  100. package/src/prover/isabelle/isar/type-check.ts +11 -25
  101. package/src/prover/isabelle/provers/blast/blast.ts +10 -41
  102. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  103. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  104. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  105. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  106. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  107. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  108. package/src/prover/isabelle/provers/classical.ts +14 -42
  109. package/src/prover/isabelle/provers/hypsubst.ts +11 -25
  110. package/src/prover/isabelle/pure/bicompose.ts +16 -13
  111. package/src/prover/isabelle/pure/consts.ts +1 -7
  112. package/src/prover/isabelle/pure/conv.ts +1 -9
  113. package/src/prover/isabelle/pure/drule.ts +24 -40
  114. package/src/prover/isabelle/pure/envir.ts +3 -52
  115. package/src/prover/isabelle/pure/goal.ts +1 -7
  116. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  117. package/src/prover/isabelle/pure/list.ts +0 -3
  118. package/src/prover/isabelle/pure/logic.ts +1 -14
  119. package/src/prover/isabelle/pure/name.ts +2 -9
  120. package/src/prover/isabelle/pure/net.ts +3 -59
  121. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  122. package/src/prover/isabelle/pure/pattern.ts +2 -19
  123. package/src/prover/isabelle/pure/raw-simplifier.ts +13 -49
  124. package/src/prover/isabelle/pure/rewriter.ts +26 -58
  125. package/src/prover/isabelle/pure/search.ts +3 -10
  126. package/src/prover/isabelle/pure/seq.ts +1 -10
  127. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  128. package/src/prover/isabelle/pure/table.ts +1 -31
  129. package/src/prover/isabelle/pure/tactic.ts +12 -22
  130. package/src/prover/isabelle/pure/tactical.ts +6 -12
  131. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  132. package/src/prover/isabelle/pure/term.ts +2 -43
  133. package/src/prover/isabelle/pure/thm.ts +13 -36
  134. package/src/prover/isabelle/pure/type.ts +2 -15
  135. package/src/prover/isabelle/pure/unify.ts +20 -30
  136. package/src/prover/isabelle/pure/variable.ts +3 -7
  137. package/src/prover/isabelle/tla/classical-setup.ts +9 -19
  138. package/src/prover/isabelle/tla/context.ts +8 -16
  139. package/src/prover/isabelle/tla/logic.ts +4 -11
  140. package/src/prover/isabelle/tla/simpdata.ts +46 -34
  141. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  142. package/src/prover/ocaml.ts +0 -6
  143. package/src/prover/prep/action.ts +4 -36
  144. package/src/prover/prep/enabled-axioms.ts +12 -19
  145. package/src/prover/prep/fingerprint.ts +0 -16
  146. package/src/prover/prep/level-comparison.ts +8 -12
  147. package/src/prover/prep/md5.ts +0 -2
  148. package/src/prover/prep/methods.ts +9 -36
  149. package/src/prover/prep/normalize.ts +4 -28
  150. package/src/prover/prove-worker.ts +0 -2
  151. package/src/prover/prove.ts +0 -36
  152. package/src/prover/ptl/decide.ts +7 -12
  153. package/src/prover/ptl/encode.ts +14 -36
  154. package/src/prover/ptl/sat.ts +24 -32
  155. package/src/prover/ptl/tableau.ts +12 -26
  156. package/src/prover/smt/axioms.ts +0 -7
  157. package/src/prover/smt/context.ts +19 -26
  158. package/src/prover/smt/data.ts +51 -54
  159. package/src/prover/smt/encode.ts +14 -35
  160. package/src/prover/smt/extensionality.ts +0 -10
  161. package/src/prover/smt/flatten.ts +3 -22
  162. package/src/prover/smt/format.ts +5 -10
  163. package/src/prover/smt/instances.ts +0 -10
  164. package/src/prover/smt/rewrite.ts +66 -101
  165. package/src/prover/smt/solver/act-cache.ts +0 -15
  166. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  167. package/src/prover/smt/solver/array.ts +1 -3
  168. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  169. package/src/prover/smt/solver/ast-lt.ts +1 -11
  170. package/src/prover/smt/solver/ast-util.ts +1 -6
  171. package/src/prover/smt/solver/ast.ts +1 -143
  172. package/src/prover/smt/solver/auf-solver.ts +6 -39
  173. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  174. package/src/prover/smt/solver/cg-table.ts +1 -18
  175. package/src/prover/smt/solver/clause.ts +1 -27
  176. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  177. package/src/prover/smt/solver/context.ts +4 -61
  178. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  179. package/src/prover/smt/solver/der.ts +2 -21
  180. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  181. package/src/prover/smt/solver/e-matching.ts +3 -34
  182. package/src/prover/smt/solver/enode.ts +1 -21
  183. package/src/prover/smt/solver/expr-ref.ts +1 -5
  184. package/src/prover/smt/solver/expr-safe-replace.ts +0 -5
  185. package/src/prover/smt/solver/fingerprints.ts +1 -12
  186. package/src/prover/smt/solver/flat-literals.ts +1 -9
  187. package/src/prover/smt/solver/goal.ts +2 -14
  188. package/src/prover/smt/solver/hash.ts +0 -8
  189. package/src/prover/smt/solver/hashtable.ts +1 -12
  190. package/src/prover/smt/solver/internalizer.ts +6 -98
  191. package/src/prover/smt/solver/lbool.ts +1 -2
  192. package/src/prover/smt/solver/literal.ts +0 -3
  193. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  194. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  195. package/src/prover/smt/solver/lp/containers.ts +12 -30
  196. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  197. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  198. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  199. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  200. package/src/prover/smt/solver/lp/dioph-eq.ts +12 -98
  201. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  202. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  203. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  204. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  205. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  206. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  207. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  208. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  209. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  210. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  211. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  212. package/src/prover/smt/solver/lp/nex.ts +1 -6
  213. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  214. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  215. package/src/prover/smt/solver/lp/nla-core.ts +35 -130
  216. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  217. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  218. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  220. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  221. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  222. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  223. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  224. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  225. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  226. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  227. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  228. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  229. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  230. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  231. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  232. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  233. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  234. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  235. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  236. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  237. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  238. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  239. package/src/prover/smt/solver/mam-compiler.ts +14 -56
  240. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  241. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  242. package/src/prover/smt/solver/model-checker.ts +2 -36
  243. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  244. package/src/prover/smt/solver/model-finder.ts +3 -15
  245. package/src/prover/smt/solver/model-generator.ts +1 -12
  246. package/src/prover/smt/solver/model-macro-solver.ts +12 -69
  247. package/src/prover/smt/solver/nlsat/algebraic.ts +55 -151
  248. package/src/prover/smt/solver/nlsat/atoms.ts +5 -19
  249. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  250. package/src/prover/smt/solver/nlsat/explain.ts +3 -47
  251. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  252. package/src/prover/smt/solver/nlsat/levelwise.ts +48 -129
  253. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  254. package/src/prover/smt/solver/nlsat/polynomial.ts +17 -156
  255. package/src/prover/smt/solver/nlsat/solver.ts +7 -67
  256. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  257. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -44
  258. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  259. package/src/prover/smt/solver/nnf.ts +3 -38
  260. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  261. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  262. package/src/prover/smt/solver/propagate-values.ts +1 -10
  263. package/src/prover/smt/solver/proto-model.ts +3 -48
  264. package/src/prover/smt/solver/pull-quant.ts +1 -12
  265. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  266. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  267. package/src/prover/smt/solver/qe-lite.ts +3 -33
  268. package/src/prover/smt/solver/qi-queue.ts +1 -16
  269. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  270. package/src/prover/smt/solver/quantifier-analyzer.ts +17 -37
  271. package/src/prover/smt/solver/quantifier-manager.ts +1 -8
  272. package/src/prover/smt/solver/random-gen.ts +1 -2
  273. package/src/prover/smt/solver/rational.ts +1 -8
  274. package/src/prover/smt/solver/ref-vector.ts +1 -6
  275. package/src/prover/smt/solver/relevancy.ts +2 -15
  276. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  277. package/src/prover/smt/solver/rewriter.ts +3 -85
  278. package/src/prover/smt/solver/rlimit.ts +2 -20
  279. package/src/prover/smt/solver/smtlib-parser.ts +2 -37
  280. package/src/prover/smt/solver/solver.ts +23 -34
  281. package/src/prover/smt/solver/sort.ts +1 -5
  282. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  283. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  284. package/src/prover/smt/solver/theory-lra-bounds.ts +0 -5
  285. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  286. package/src/prover/smt/solver/theory-lra-internalize.ts +1 -27
  287. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  288. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  289. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  290. package/src/prover/smt/solver/theory-lra.ts +1 -8
  291. package/src/prover/smt/solver/var-subst.ts +2 -26
  292. package/src/prover/smt/table.ts +0 -8
  293. package/src/prover/tlapm/cache.ts +20 -25
  294. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  295. package/src/prover/tlapm/tlapm.ts +12 -17
  296. package/src/prover/verdict.ts +0 -2
  297. package/src/prover/zenon/check/check.ts +0 -9
  298. package/src/prover/zenon/check/definitions.ts +5 -15
  299. package/src/prover/zenon/check/equality.ts +0 -8
  300. package/src/prover/zenon/check/functions.ts +0 -4
  301. package/src/prover/zenon/check/keys.ts +0 -7
  302. package/src/prover/zenon/check/propositional.ts +0 -3
  303. package/src/prover/zenon/check/records.ts +0 -5
  304. package/src/prover/zenon/check/relations.ts +0 -13
  305. package/src/prover/zenon/check/rewrites.ts +0 -6
  306. package/src/prover/zenon/check/sets.ts +0 -3
  307. package/src/prover/zenon/check/terms.ts +0 -17
  308. package/src/prover/zenon/check/tla.ts +0 -6
  309. package/src/prover/zenon/decide.ts +0 -12
  310. package/src/prover/zenon/encode.ts +1 -8
  311. package/src/prover/zenon/eqrel.ts +0 -13
  312. package/src/prover/zenon/equality-rules.ts +0 -4
  313. package/src/prover/zenon/expr.ts +1 -26
  314. package/src/prover/zenon/index-table.ts +17 -38
  315. package/src/prover/zenon/isar-case.ts +9 -19
  316. package/src/prover/zenon/isar.ts +1 -29
  317. package/src/prover/zenon/limits.ts +0 -4
  318. package/src/prover/zenon/llproof.ts +0 -9
  319. package/src/prover/zenon/mltoll.ts +54 -76
  320. package/src/prover/zenon/node.ts +1 -11
  321. package/src/prover/zenon/ocaml.ts +1 -17
  322. package/src/prover/zenon/parse.ts +2 -7
  323. package/src/prover/zenon/phrase.ts +1 -11
  324. package/src/prover/zenon/proof.ts +0 -9
  325. package/src/prover/zenon/propositional-rules.ts +0 -5
  326. package/src/prover/zenon/rules.ts +2 -6
  327. package/src/prover/zenon/search.ts +1 -17
  328. package/src/prover/zenon/tla/functions.ts +57 -29
  329. package/src/prover/zenon/tla/llproof.ts +63 -70
  330. package/src/prover/zenon/tla/records.ts +56 -27
  331. package/src/prover/zenon/tla/rewrites.ts +12 -19
  332. package/src/prover/zenon/tla/sets.ts +68 -39
  333. package/src/prover/zenon/tla/terms.ts +0 -6
  334. package/src/prover/zenon/tla/tla.ts +59 -58
  335. package/src/randomization.ts +81 -35
  336. package/src/resolve.ts +12 -112
  337. package/src/runtime.ts +22 -22
  338. package/src/sany/builtins.ts +2 -5
  339. package/src/sany/generator.ts +149 -252
  340. package/src/sany/levels.ts +6 -34
  341. package/src/sany/lexer.ts +41 -61
  342. package/src/sany/linter.ts +1 -9
  343. package/src/sany/modules.ts +1 -5
  344. package/src/sany/nodes.ts +0 -31
  345. package/src/sany/parse-error.ts +39 -117
  346. package/src/sany/report.ts +29 -63
  347. package/src/sany/selectors.ts +15 -39
  348. package/src/sany/source.ts +1 -17
  349. package/src/sany/xml.ts +13 -63
  350. package/src/search.ts +495 -155
  351. package/src/simulate.ts +685 -0
  352. package/src/spec-description.ts +176 -69
  353. package/src/standard-definitions.ts +0 -4
  354. package/src/standard-modules.ts +254 -69
  355. package/src/state-graph.ts +50 -24
  356. package/src/subexpressions.ts +69 -52
  357. package/src/substitution-levels.ts +2 -3
  358. package/src/successors.ts +263 -94
  359. package/src/symmetry.ts +33 -25
  360. package/src/tableau.ts +27 -24
  361. package/src/tlc/fingerprint.ts +183 -67
  362. package/src/tlc/jar-data.ts +112 -6
  363. package/src/tlc/messages.ts +110 -44
  364. package/src/tlc/order.ts +37 -60
  365. package/src/tlc/random.ts +33 -45
  366. package/src/tlc/replay.ts +549 -217
  367. package/src/tlc/summary.ts +36 -47
  368. package/src/tlc/tlc-operators.ts +76 -41
  369. package/src/tlc/tlcext-operators.ts +139 -122
  370. package/src/tlc/trace-spec.ts +269 -0
  371. package/src/tlc/value-stream.ts +139 -0
  372. package/src/tlc/version.ts +1 -4
  373. package/src/transfer.ts +22 -25
  374. package/src/typescript/actions.ts +481 -0
  375. package/src/typescript/collections.ts +600 -0
  376. package/src/typescript/compile.ts +65 -0
  377. package/src/typescript/context.ts +94 -0
  378. package/src/typescript/emit.ts +121 -0
  379. package/src/typescript/expressions.ts +496 -0
  380. package/src/typescript/formula.ts +152 -0
  381. package/src/typescript/functions.ts +284 -0
  382. package/src/typescript/model.ts +163 -0
  383. package/src/typescript/names.ts +114 -0
  384. package/src/typescript/program.ts +48 -0
  385. package/src/typescript/properties.ts +139 -0
  386. package/src/typescript/scope.ts +112 -0
  387. package/src/typescript/steps.ts +165 -0
  388. package/src/typescript/types.ts +171 -0
  389. package/src/values.ts +780 -337
  390. package/src/worker.ts +7 -8
package/src/successors.ts CHANGED
@@ -7,7 +7,12 @@ import {
7
7
  } from "./ast";
8
8
  import { getKindString } from "./builtins";
9
9
  import { getReadVariables } from "./dependencies";
10
- import { TlaEvaluationError, TlaIllegalStateError, TlaIncompleteSuccessorError } from "./errors";
10
+ import {
11
+ TlaEvaluationError,
12
+ TlaIllegalStateError,
13
+ TlaIncompleteSuccessorError,
14
+ TlaUncodedError,
15
+ } from "./errors";
11
16
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
12
17
  import {
13
18
  describeLocation,
@@ -16,10 +21,10 @@ import {
16
21
  bindLazyArguments,
17
22
  bindDefinitions,
18
23
  bindOperatorArguments,
24
+ bindPattern,
19
25
  bindValue,
20
26
  compileArgumentScope,
21
27
  evaluate,
22
- expectBoolean,
23
28
  forEachBinding,
24
29
  getLazyFunction,
25
30
  toKeepLazyContext,
@@ -27,7 +32,9 @@ import {
27
32
  getContextElements,
28
33
  getEntryEvaluator,
29
34
  getReevaluatedDefinitions,
35
+ getStartupValue,
30
36
  lookupScope,
37
+ mapBoundSets,
31
38
  resolveApplyOperator,
32
39
  resolveGlobalOperator,
33
40
  toUnspecifiedSubscriptError,
@@ -38,13 +45,21 @@ import {
38
45
  type State,
39
46
  } from "./evaluate";
40
47
  import { mapChildren } from "./instances";
41
- import { isAssignedShortcut, LITERAL_KINDS, replayEnabled } from "./tlc/replay";
48
+ import { CORE_OPERATORS } from "./standard-modules";
49
+ import { getRandomSubset, nextPrime, type JavaRandom } from "./tlc/random";
50
+ import {
51
+ getEnabledFailure,
52
+ isAssignedShortcut,
53
+ LITERAL_KINDS,
54
+ replayEnabled,
55
+ warnChangedUnchanged,
56
+ } from "./tlc/replay";
42
57
  import {
43
58
  formatValue,
44
59
  getStreamedElements,
60
+ isEqualLikeTlc,
45
61
  isFunctionValue,
46
62
  isTlcEnumerable,
47
- valuesEqual,
48
63
  type Value,
49
64
  } from "./values";
50
65
 
@@ -56,10 +71,12 @@ export interface Successor {
56
71
  interface Run {
57
72
  environment: Environment;
58
73
  isInit: boolean;
59
- // Whether the run computes ENABLED rather than the successors of the state.
60
74
  isEnabled: boolean;
61
75
  current: Value[] | undefined;
62
76
  isStopped: boolean;
77
+ generator: JavaRandom | undefined;
78
+ successors: number;
79
+ onUnsatisfied?: (state: Value[], conjunct: Expression) => void;
63
80
  }
64
81
 
65
82
  type Continuation = (partial: State, action: string | undefined) => void;
@@ -76,7 +93,7 @@ type Runner = (
76
93
  type Conjunct = { expression: Expression } & (
77
94
  | { kind: "Guard" }
78
95
  | { kind: "Assign"; index: number; value: Expression }
79
- | { kind: "Unchanged"; indices: number[] }
96
+ | { kind: "Unchanged"; variables: UnchangedVariable[] }
80
97
  | { kind: "Branch"; runner: Runner }
81
98
  );
82
99
 
@@ -94,18 +111,14 @@ const assign = (partial: State, index: number, value: Value) => {
94
111
  return copy;
95
112
  };
96
113
 
97
- // What TLC says it was computing when it fails.
98
114
  const getComputation = (run: Run) =>
99
115
  run.isInit ? "initial states" : run.isEnabled ? "ENABLED" : "next states";
100
116
 
101
- // TLC fails with an unexpected exception when it fails to compute the next states or ENABLED.
102
117
  const createRunError = (run: Run, message: string) => {
103
118
  const error = new TlaEvaluationError(message);
104
119
  return run.isInit ? error : setExitCode(error, EXIT_STATUS.error);
105
120
  };
106
121
 
107
- // TLC's message for a conjunct that isn't a boolean, which differs for a literal it walks to rather
108
- // than evaluates.
109
122
  const getNonBooleanMessage = (
110
123
  run: Run,
111
124
  value: Value,
@@ -121,7 +134,6 @@ const getNonBooleanMessage = (
121
134
  return `In computing ${getComputation(run)}, TLC expected a boolean expression,\nbut instead found ${formatValue(value)}.\n${node}`;
122
135
  };
123
136
 
124
- // TLC words an IF whose condition isn't a boolean differently for each computation.
125
137
  const getIfConditionMessage = (run: Run, value: Value, expression: Expression) => {
126
138
  const kind = getKindString(value);
127
139
  const range = describeRange(expression);
@@ -134,9 +146,19 @@ const getIfConditionMessage = (run: Run, value: Value, expression: Expression) =
134
146
  const holds = (run: Run, expression: Expression, context: Context) =>
135
147
  holdsValue(run, expression, evaluate(expression, context));
136
148
 
149
+ const CORE_OPERATOR_NAMES = new Set(CORE_OPERATORS.map((operator) => operator.name));
150
+
151
+ const isBuiltInOperation = (expression: Expression) =>
152
+ expression.kind === "Apply"
153
+ ? CORE_OPERATOR_NAMES.has(expression.operator)
154
+ : expression.kind !== "Identifier" && !LITERAL_KINDS.has(expression.kind);
155
+
137
156
  const holdsValue = (run: Run, expression: Expression, value: Value, isWalked = true) => {
138
157
  if (typeof value === "boolean") return value;
139
- throw createRunError(run, getNonBooleanMessage(run, value, expression, isWalked));
158
+ const message = getNonBooleanMessage(run, value, expression, isWalked);
159
+ throw run.isInit && isWalked && isBuiltInOperation(expression)
160
+ ? new TlaUncodedError(message)
161
+ : createRunError(run, message);
140
162
  };
141
163
 
142
164
  const evaluateCached = (
@@ -156,7 +178,12 @@ const getRunner = (expression: Expression, environment: Environment, isInit: boo
156
178
  const runners = isInit ? initRunners : nextRunners;
157
179
  const cached = runners.get(expression);
158
180
  if (cached) return cached;
159
- const runner = compileAction(expression, environment, isInit);
181
+ const deterministic = compileAction(expression, environment, isInit);
182
+ const random = isInit ? undefined : compileRandomAction(expression, environment);
183
+ const runner: Runner = random
184
+ ? (run, scope, partial, action, isFixed, onComplete) =>
185
+ (run.generator ? random : deterministic)(run, scope, partial, action, isFixed, onComplete)
186
+ : deterministic;
160
187
  runners.set(expression, runner);
161
188
  return runner;
162
189
  };
@@ -204,7 +231,7 @@ const getRuntimeVariableIndex = (
204
231
  }
205
232
  if (expression.kind !== "Identifier") return undefined;
206
233
  const binding = lookupScope(scope, expression.name);
207
- if (binding?.kind === "Thunk") {
234
+ if (binding?.kind === "Thunk" && !binding.isReleased) {
208
235
  return getRuntimeVariableIndex(binding.expression, binding.scope, partial, run, isPrimed);
209
236
  }
210
237
  if (binding) return undefined;
@@ -220,24 +247,29 @@ const isPossiblyAssignable = (target: Expression, isInit: boolean) =>
220
247
  (target.kind === "Identifier" && (isInit || isLocallyResolved(target))) ||
221
248
  (!isInit && target.kind === "Prime");
222
249
 
223
- const getUnchangedIndices = (
250
+ interface UnchangedVariable {
251
+ index: number;
252
+ expression: Expression;
253
+ }
254
+
255
+ const getUnchangedVariables = (
224
256
  expression: Expression,
225
257
  environment: Environment,
226
258
  visited = new Set<string>(),
227
- ): number[] | undefined => {
259
+ ): UnchangedVariable[] | undefined => {
228
260
  if (expression.kind === "Tuple") {
229
- const indices = expression.elements.map((element) =>
230
- getUnchangedIndices(element, environment, visited),
261
+ const variables = expression.elements.map((element) =>
262
+ getUnchangedVariables(element, environment, visited),
231
263
  );
232
- return indices.every((item) => item !== undefined) ? indices.flat() : undefined;
264
+ return variables.every((item) => item !== undefined) ? variables.flat() : undefined;
233
265
  }
234
266
  if (expression.kind !== "Identifier" || visited.has(expression.name)) return undefined;
235
267
  const index = environment.variableIndex.get(expression.name);
236
- if (index !== undefined) return [index];
268
+ if (index !== undefined) return [{ index, expression }];
237
269
  const definition = getZeroArityBody(expression.name, environment);
238
270
  if (!definition) return undefined;
239
271
  visited.add(expression.name);
240
- return getUnchangedIndices(definition.body, environment, visited);
272
+ return getUnchangedVariables(definition.body, environment, visited);
241
273
  };
242
274
 
243
275
  const ACTION_KINDS = new Set([
@@ -277,9 +309,7 @@ const isGuard = (expression: Expression, environment: Environment, isInit: boole
277
309
 
278
310
  const NO_NAMES: ReadonlySet<string> = new Set();
279
311
 
280
- // The local names an expression reads from enclosing scopes, or undefined when it applies a local
281
- // operator, whose body may assign variables.
282
- export const getReadLocals = (
312
+ const getReadLocals = (
283
313
  expression: Expression,
284
314
  bound: ReadonlySet<string>,
285
315
  ): string[] | undefined => {
@@ -288,20 +318,18 @@ export const getReadLocals = (
288
318
  return bound.has(expression.name) ? [] : [expression.name];
289
319
  }
290
320
  const names: string[] = [];
291
- const result = { isReadOnly: true };
321
+ let isReadOnly = true;
292
322
  mapChildren(expression, (child, childNames) => {
293
- const childLocals = result.isReadOnly
323
+ const childLocals = isReadOnly
294
324
  ? getReadLocals(child, childNames.length === 0 ? bound : new Set([...bound, ...childNames]))
295
325
  : [];
296
326
  if (childLocals) names.push(...childLocals);
297
- else result.isReadOnly = false;
327
+ else isReadOnly = false;
298
328
  return child;
299
329
  });
300
- return result.isReadOnly ? names : undefined;
330
+ return isReadOnly ? names : undefined;
301
331
  };
302
332
 
303
- // TLC generates a successor for every disjunct and witness that holds, so an expression only
304
- // checks like a guard when it has neither.
305
333
  const hasBranches = (
306
334
  expression: Expression,
307
335
  environment: Environment,
@@ -337,15 +365,13 @@ const toConjunct = (
337
365
  }
338
366
  }
339
367
  if (!isInit && expression.kind === "Unchanged") {
340
- const indices = getUnchangedIndices(expression.expression, environment);
341
- if (indices) return { kind: "Unchanged", expression, indices };
368
+ const variables = getUnchangedVariables(expression.expression, environment);
369
+ if (variables) return { kind: "Unchanged", expression, variables };
342
370
  }
343
371
  if (isGuard(expression, environment, isInit)) return { kind: "Guard", expression };
344
372
  return { kind: "Branch", expression, runner: getRunner(expression, environment, isInit) };
345
373
  };
346
374
 
347
- // The leading guards of `\E x \in S, y \in T : P /\ Q` that read no inner bound hold for every inner
348
- // binding alike, so they can run once for each element of the outermost bound.
349
375
  const getHoistedGuards = (expression: QuantifierExpression, environment: Environment) => {
350
376
  if (expression.bounds.length < 2 || expression.body.kind !== "And") return undefined;
351
377
  const names = expression.bounds.flatMap((bound) =>
@@ -388,9 +414,25 @@ const compileConjunction = (
388
414
  if (index > 0 && isShortcut && isComplete(current)) {
389
415
  context ??= getContext(run, scope, current);
390
416
  for (let rest = index; rest < conjuncts.length; rest++) {
391
- const expression = conjuncts[rest].expression;
417
+ const conjunct = conjuncts[rest];
418
+ const state = run.current;
419
+ const changed =
420
+ state && conjunct.kind === "Unchanged"
421
+ ? conjunct.variables.find((variable) => {
422
+ const assigned = current[variable.index];
423
+ return assigned !== undefined && !isEqualLikeTlc(assigned, state[variable.index]);
424
+ })
425
+ : undefined;
426
+ if (changed) {
427
+ warnChangedUnchanged(run.environment, changed.index, changed.expression);
428
+ return;
429
+ }
430
+ const expression = conjunct.expression;
392
431
  const value = evaluateCached(restEvaluators, rest, expression, context);
393
- if (!holdsValue(run, expression, value, false)) return;
432
+ if (!holdsValue(run, expression, value, false)) {
433
+ run.onUnsatisfied?.(current, expression);
434
+ return;
435
+ }
394
436
  }
395
437
  onComplete(current, action);
396
438
  return;
@@ -409,7 +451,7 @@ const compileConjunction = (
409
451
  if (assigned === undefined) {
410
452
  current = assign(current, conjunct.index, value);
411
453
  context = undefined;
412
- } else if (!valuesEqual(assigned, value)) {
454
+ } else if (!isEqualLikeTlc(assigned, value)) {
413
455
  return;
414
456
  }
415
457
  continue;
@@ -418,12 +460,13 @@ const compileConjunction = (
418
460
  const state = run.current;
419
461
  if (!state) return;
420
462
  let unchanged: State | undefined;
421
- for (const variable of conjunct.indices) {
422
- const assigned = (unchanged ?? current)[variable];
463
+ for (const variable of conjunct.variables) {
464
+ const assigned = (unchanged ?? current)[variable.index];
423
465
  if (assigned === undefined) {
424
466
  unchanged ??= current.slice();
425
- unchanged[variable] = state[variable];
426
- } else if (!valuesEqual(assigned, state[variable])) {
467
+ unchanged[variable.index] = state[variable.index];
468
+ } else if (!isEqualLikeTlc(assigned, state[variable.index])) {
469
+ warnChangedUnchanged(run.environment, variable.index, variable.expression);
427
470
  return;
428
471
  }
429
472
  }
@@ -445,11 +488,13 @@ const compileConjunction = (
445
488
  runFrom(0, run, scope, partial, action, onComplete);
446
489
  };
447
490
 
448
- const compileGuard =
449
- (expression: Expression): Runner =>
450
- (run, scope, partial, action, _isFixed, onComplete) => {
491
+ const compileGuard = (expression: Expression): Runner => {
492
+ const enabledFailure = getEnabledFailure(expression);
493
+ return (run, scope, partial, action, _isFixed, onComplete) => {
494
+ if (run.isEnabled && enabledFailure !== undefined) throw createRunError(run, enabledFailure);
451
495
  if (holds(run, expression, getContext(run, scope, partial))) onComplete(partial, action);
452
496
  };
497
+ };
453
498
 
454
499
  const compileMembership = (
455
500
  expression: Expression & { kind: "Apply" },
@@ -473,6 +518,17 @@ const compileMembership = (
473
518
  throw createRunError(run, `${message}\n${describeRange(expression)}`);
474
519
  }
475
520
  const elements = getStreamedElements(value);
521
+ if (run.generator) {
522
+ for (const element of getRandomSubset(
523
+ elements.length,
524
+ value,
525
+ run.environment.runtime.getRandom(),
526
+ run.environment.runtime.version,
527
+ )) {
528
+ onComplete(assign(partial, index, element), action);
529
+ if (run.successors > 0 || run.isStopped) return;
530
+ }
531
+ }
476
532
  for (let position = 0; position < elements.length && !run.isStopped; position++) {
477
533
  onComplete(assign(partial, index, elements[position]), action);
478
534
  }
@@ -520,8 +576,6 @@ const compileDynamicAssignment = (
520
576
  };
521
577
  };
522
578
 
523
- // Tool.getInitStates and Tool.getNextStates walk the body of a function they apply that is still
524
- // lazy, which they evaluate as TLC computes the initial states eagerly, and otherwise apply it.
525
579
  const compileFunctionAction = (
526
580
  expression: Expression & { kind: "FunctionApplication" },
527
581
  environment: Environment,
@@ -561,15 +615,15 @@ const compileFunctionAction = (
561
615
  };
562
616
 
563
617
  const compileUnchanged = (expression: Expression, environment: Environment): Runner => {
564
- const indices = getUnchangedIndices(expression, environment);
565
- if (indices) return compileConjunction([getUnchangedWrapper(expression)], environment, false);
618
+ if (getUnchangedVariables(expression, environment))
619
+ return compileConjunction([getUnchangedWrapper(expression)], environment, false);
566
620
  if (expression.kind === "Tuple")
567
621
  return getRunner(getUnchangedWrapper(expression), environment, false);
568
622
  const unchanged = getUnchangedWrapper(expression);
569
623
  return (run, scope, partial, action, isFixed, onComplete) => {
570
624
  const binding =
571
625
  expression.kind === "Identifier" ? lookupScope(scope, expression.name) : undefined;
572
- if (binding?.kind === "Thunk") {
626
+ if (binding?.kind === "Thunk" && !binding.isReleased) {
573
627
  getRunner(getUnchangedWrapper(binding.expression), environment, false)(
574
628
  run,
575
629
  binding.scope,
@@ -580,7 +634,22 @@ const compileUnchanged = (expression: Expression, environment: Environment): Run
580
634
  );
581
635
  return;
582
636
  }
583
- if (holds(run, unchanged, getContext(run, scope, partial))) onComplete(partial, action);
637
+ const context = getContext(run, scope, partial);
638
+ if (run.isEnabled && expression.kind === "Apply") {
639
+ const operator = resolveApplyOperator(expression, context);
640
+ if (operator?.kind === "Closure" && operator.params.length === expression.args.length) {
641
+ getRunner(getUnchangedWrapper(operator.body), environment, false)(
642
+ run,
643
+ bindOperatorArguments(operator, expression.args, context),
644
+ partial,
645
+ action,
646
+ isFixed,
647
+ onComplete,
648
+ );
649
+ return;
650
+ }
651
+ }
652
+ if (holds(run, unchanged, context)) onComplete(partial, action);
584
653
  };
585
654
  };
586
655
 
@@ -597,10 +666,10 @@ const compileCall = (
597
666
  if (global?.kind === "Builtin") return guard;
598
667
  if (global?.kind === "Closure") {
599
668
  const bindArguments = compileArgumentScope(global, expression.args, environment);
600
- const compiled = { body: undefined as Runner | undefined };
669
+ let bodyRunner: Runner | undefined;
601
670
  return (run, scope, partial, action, isFixed, onComplete) => {
602
- compiled.body ??= getRunner(global.body, environment, isInit);
603
- compiled.body(
671
+ bodyRunner ??= getRunner(global.body, environment, isInit);
672
+ bodyRunner(
604
673
  run,
605
674
  bindArguments(getContext(run, scope, partial)),
606
675
  partial,
@@ -637,10 +706,10 @@ const compileIdentifier = (
637
706
  const definition = isLocallyResolved(expression)
638
707
  ? undefined
639
708
  : getZeroArityBody(expression.name, environment);
640
- const compiled = { body: undefined as Runner | undefined };
709
+ let bodyRunner: Runner | undefined;
641
710
  return (run, scope, partial, action, isFixed, onComplete) => {
642
711
  const binding = lookupScope(scope, expression.name);
643
- if (binding?.kind === "Thunk") {
712
+ if (binding?.kind === "Thunk" && !binding.isReleased) {
644
713
  getRunner(binding.expression, environment, isInit)(
645
714
  run,
646
715
  binding.scope,
@@ -651,20 +720,19 @@ const compileIdentifier = (
651
720
  );
652
721
  return;
653
722
  }
654
- if (binding || !definition) {
723
+ if (
724
+ binding ||
725
+ !definition ||
726
+ (expression.location.range && getStartupValue(definition, environment) !== undefined)
727
+ ) {
655
728
  guard(run, scope, partial, action, isFixed, onComplete);
656
729
  return;
657
730
  }
658
- compiled.body ??= getRunner(definition.body, environment, isInit);
659
- compiled.body(run, undefined, partial, isFixed ? action : definition.name, isFixed, onComplete);
731
+ bodyRunner ??= getRunner(definition.body, environment, isInit);
732
+ bodyRunner(run, undefined, partial, isFixed ? action : definition.name, isFixed, onComplete);
660
733
  };
661
734
  };
662
735
 
663
- // A PlusCal action starts with a guard such as pc[self] = "L1", and a process is a disjunction of
664
- // its actions. The labels an expression requires of one variable at one bound name let a
665
- // disjunction skip the operands whose guard is false without evaluating them. A hand-written
666
- // action often puts other guards first, such as running = self /\ pc[self] = "L1". TLC evaluates
667
- // those before the label's guard, so a skipped operand still runs them, for their errors.
668
736
  interface LabelGuard {
669
737
  variable: number;
670
738
  argument: string;
@@ -689,16 +757,12 @@ const toLabelGuard = (expression: Expression, environment: Environment) => {
689
757
  const getConjuncts = (expression: Expression): Expression[] =>
690
758
  expression.kind === "And" ? expression.operands.flatMap(getConjuncts) : [expression];
691
759
 
692
- // What may come before the label's guard: a comparison or a name that a conjunction checks as a
693
- // guard. An operand with another conjunct first, such as an assignment or a name defined as an
694
- // action that may branch, runs in full.
695
760
  const isLeadingGuard = (expression: Expression, environment: Environment) =>
696
761
  (expression.kind === "Identifier" ||
697
762
  (expression.kind === "Apply" &&
698
763
  (expression.operator === "=" || expression.operator === "#"))) &&
699
764
  isGuard(expression, environment, false);
700
765
 
701
- // Checks the guards before a label's guard as a conjunction does, for TLC's errors.
702
766
  const compileLeadingGuards = (guards: Expression[]) => {
703
767
  const evaluators: (Evaluator | undefined)[] = [];
704
768
  return (run: Run, scope: Scope | undefined, partial: State) => {
@@ -813,6 +877,66 @@ const compileDisjunction = (
813
877
  };
814
878
  };
815
879
 
880
+ const compileRandomChoice =
881
+ (choices: Runner[]): Runner =>
882
+ (run, scope, partial, action, isFixed, onComplete) => {
883
+ const generator = run.generator;
884
+ if (!generator) throw new Error("A random choice needs the run's generator");
885
+ const start = Math.floor(generator.nextDouble() * choices.length);
886
+ const prime = nextPrime(generator);
887
+ for (let attempt = 0; attempt < choices.length; attempt++) {
888
+ choices[(start + attempt * prime) % choices.length](
889
+ run,
890
+ scope,
891
+ partial,
892
+ action,
893
+ isFixed,
894
+ onComplete,
895
+ );
896
+ if (run.successors > 0 || run.isStopped) return;
897
+ }
898
+ };
899
+
900
+ const compileRandomExists = (
901
+ expression: QuantifierExpression,
902
+ environment: Environment,
903
+ ): Runner => {
904
+ const body = getRunner(expression.body, environment, false);
905
+ return (run, scope, partial, action, isFixed, onComplete) => {
906
+ const context = getContext(run, scope, partial);
907
+ const version = environment.runtime.version;
908
+ const orders = mapBoundSets(expression.bounds, (set) => evaluate(set, context)).map(
909
+ (set, index) =>
910
+ getRandomSubset(
911
+ getContextElements(set, expression.bounds[index].set, version).length,
912
+ set,
913
+ environment.runtime.getRandom(),
914
+ version,
915
+ ),
916
+ );
917
+ const visit = (position: number, boundScope: Scope | undefined): boolean => {
918
+ if (position < 0) {
919
+ body(run, boundScope, partial, action, isFixed, onComplete);
920
+ return run.successors > 0 || run.isStopped;
921
+ }
922
+ const pattern = expression.bounds[position].pattern;
923
+ return orders[position].some((element) =>
924
+ visit(position - 1, bindPattern(boundScope, pattern, element)),
925
+ );
926
+ };
927
+ visit(orders.length - 1, scope);
928
+ };
929
+ };
930
+
931
+ const compileRandomAction = (expression: Expression, environment: Environment) => {
932
+ if (expression.kind === "Exists") return compileRandomExists(expression, environment);
933
+ if (expression.kind !== "Or") return undefined;
934
+ const runners = expression.operands.map((operand) => getRunner(operand, environment, false));
935
+ return expression.isBulleted
936
+ ? compileRandomChoice(runners)
937
+ : runners.reduce((left, right) => compileRandomChoice([left, right]));
938
+ };
939
+
816
940
  const compileAction = (
817
941
  expression: Expression,
818
942
  environment: Environment,
@@ -852,12 +976,8 @@ const compileAction = (
852
976
  const rest = compileConjunction(hoisted.rest, environment, isInit);
853
977
  return (run, scope, partial, action, isFixed, onComplete) => {
854
978
  const context = getContext(run, scope, partial);
855
- const sets = expression.bounds.map((innerBound) =>
856
- getContextElements(
857
- evaluate(innerBound.set, context),
858
- innerBound.set,
859
- environment.runtime.version,
860
- ),
979
+ const sets = mapBoundSets(expression.bounds, (set) =>
980
+ getContextElements(evaluate(set, context), set, environment.runtime.version),
861
981
  );
862
982
  if (sets.some((elements) => elements.length === 0)) return;
863
983
  const visit = (index: number, boundScope: Scope | undefined): void => {
@@ -955,7 +1075,6 @@ const compileAction = (
955
1075
  const arm = arms.find((candidate) => {
956
1076
  const value = evaluate(candidate.condition, context);
957
1077
  if (typeof value === "boolean") return value;
958
- // TLC leaves out the space before the kind under ENABLED.
959
1078
  throw createRunError(
960
1079
  run,
961
1080
  `In computing ${getComputation(run)}, a non-boolean expression${run.isEnabled ? "" : " "}(${getKindString(value)}) was used as a guard condition of a CASE.\n${describeNode(candidate.source)}`,
@@ -995,7 +1114,11 @@ const compileAction = (
995
1114
  return compileUnchanged(expression.expression, environment);
996
1115
  case "AngleAction": {
997
1116
  const body = getChildRunner(expression.action);
998
- const unchanged = getUnchangedWrapper(expression.subscript);
1117
+ const unchanged: Expression = {
1118
+ kind: "Unchanged",
1119
+ expression: expression.subscript,
1120
+ location: expression.subscript.location,
1121
+ };
999
1122
  const isUnchanged = (run: Run, scope: Scope | undefined, nextPartial: State) => {
1000
1123
  try {
1001
1124
  return holds(run, unchanged, getContext(run, scope, nextPartial));
@@ -1011,11 +1134,11 @@ const compileAction = (
1011
1134
  });
1012
1135
  }
1013
1136
  case "BoxAction":
1014
- return getChildRunner({
1015
- kind: "Or",
1016
- operands: [expression.action, getUnchangedWrapper(expression.subscript)],
1017
- location: expression.location,
1018
- });
1137
+ return compileDisjunction(
1138
+ [expression.action, getUnchangedWrapper(expression.subscript)],
1139
+ environment,
1140
+ isInit,
1141
+ );
1019
1142
  case "Label":
1020
1143
  return getChildRunner(expression.body);
1021
1144
  case "Identifier":
@@ -1038,11 +1161,19 @@ const compileAction = (
1038
1161
  const right = getChildRunner(args[1]);
1039
1162
  return (run, scope, partial, action, isFixed, onComplete) => {
1040
1163
  const condition = evaluate(args[0], getContext(run, scope, partial));
1041
- const isTrue =
1042
- typeof condition === "boolean"
1043
- ? condition
1044
- : expectBoolean(condition, `the left side of => at ${describeLocation(args[0])}`);
1045
- if (!isTrue) {
1164
+ if (typeof condition !== "boolean") {
1165
+ const kind = getKindString(condition);
1166
+ const range = describeRange(expression);
1167
+ throw createRunError(
1168
+ run,
1169
+ run.isInit
1170
+ ? `In computing initial states of a predicate of form P => Q, P was ${kind}\n.${range}`
1171
+ : run.isEnabled
1172
+ ? `While computing ENABLED of an expression of the form P => Q, P was ${kind}.\n${range}`
1173
+ : `In computing next states of a predicate of the form P => Q, P was\n${kind}.\n${range}`,
1174
+ );
1175
+ }
1176
+ if (!condition) {
1046
1177
  onComplete(partial, action);
1047
1178
  return;
1048
1179
  }
@@ -1056,7 +1187,6 @@ const compileAction = (
1056
1187
  }
1057
1188
  };
1058
1189
 
1059
- // A partial state that assigns no variable, which a run fills in as it assigns them.
1060
1190
  const getEmptyState = (environment: Environment): State =>
1061
1191
  environment.variables.map((): Value | undefined => undefined);
1062
1192
 
@@ -1075,7 +1205,6 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
1075
1205
  );
1076
1206
  }
1077
1207
  const environment = context.environment;
1078
- // TLC computes ENABLED again with its call stack recorded as it computes successors.
1079
1208
  if (environment.callStack) return replayEnabled(expression, context.scope, state, environment);
1080
1209
  const run: Run = {
1081
1210
  environment,
@@ -1083,8 +1212,9 @@ export const isEnabled = (expression: Expression, context: Context): boolean =>
1083
1212
  isEnabled: true,
1084
1213
  current: state,
1085
1214
  isStopped: false,
1215
+ generator: undefined,
1216
+ successors: 0,
1086
1217
  };
1087
- // TLC stops computing ENABLED at the first successor, so it skips the rest of the action.
1088
1218
  getRunner(expression, environment, false)(
1089
1219
  run,
1090
1220
  context.scope,
@@ -1103,6 +1233,7 @@ export const forEachInitialState = (
1103
1233
  environment: Environment,
1104
1234
  onState: (state: Value[]) => boolean,
1105
1235
  scope?: Scope,
1236
+ onIncomplete?: (state: State) => boolean,
1106
1237
  ) => {
1107
1238
  const run: Run = {
1108
1239
  environment,
@@ -1110,6 +1241,8 @@ export const forEachInitialState = (
1110
1241
  isEnabled: false,
1111
1242
  current: undefined,
1112
1243
  isStopped: false,
1244
+ generator: undefined,
1245
+ successors: 0,
1113
1246
  };
1114
1247
  getRunner(expression, environment, true)(
1115
1248
  run,
@@ -1120,8 +1253,10 @@ export const forEachInitialState = (
1120
1253
  (partial) => {
1121
1254
  if (run.isStopped) return;
1122
1255
  if (!isComplete(partial)) {
1123
- // TLC reports an initial state that isn't completely specified as an illegal state, not as
1124
- // an evaluation failure.
1256
+ if (onIncomplete) {
1257
+ run.isStopped = onIncomplete([...partial]);
1258
+ return;
1259
+ }
1125
1260
  throw setExitCode(new TlaIllegalStateError([...partial]), EXIT_STATUS.error);
1126
1261
  }
1127
1262
  run.isStopped = onState(partial);
@@ -1153,6 +1288,8 @@ export const forEachSuccessor = (
1153
1288
  environment: Environment,
1154
1289
  onSuccessor: (successor: Successor) => boolean,
1155
1290
  scope?: Scope,
1291
+ generator?: JavaRandom,
1292
+ onUnsatisfied?: Run["onUnsatisfied"],
1156
1293
  ) => {
1157
1294
  const run: Run = {
1158
1295
  environment,
@@ -1160,8 +1297,10 @@ export const forEachSuccessor = (
1160
1297
  isEnabled: false,
1161
1298
  current: state,
1162
1299
  isStopped: false,
1300
+ generator,
1301
+ successors: 0,
1302
+ onUnsatisfied,
1163
1303
  };
1164
- const counter = { successors: 0 };
1165
1304
  getRunner(expression, environment, false)(
1166
1305
  run,
1167
1306
  scope,
@@ -1171,7 +1310,9 @@ export const forEachSuccessor = (
1171
1310
  (partial, action) => {
1172
1311
  if (run.isStopped) return;
1173
1312
  if (!isComplete(partial)) {
1174
- const missing = environment.variables.filter((_, index) => partial[index] === undefined);
1313
+ const missing = environment.variables.filter(
1314
+ (_name, index) => partial[index] === undefined,
1315
+ );
1175
1316
  throw new TlaIncompleteSuccessorError(
1176
1317
  `Successor state is not completely specified by action ${action ?? "Next"}. The following variables are not assigned: ${missing.join(", ")}`,
1177
1318
  partial,
@@ -1179,11 +1320,39 @@ export const forEachSuccessor = (
1179
1320
  missing,
1180
1321
  );
1181
1322
  }
1182
- counter.successors++;
1323
+ run.successors++;
1183
1324
  run.isStopped = onSuccessor({ state: partial, action });
1184
1325
  },
1185
1326
  );
1186
- return counter.successors;
1327
+ return run.successors;
1328
+ };
1329
+
1330
+ export const hasIncompleteSuccessor = (
1331
+ expression: Expression,
1332
+ state: Value[],
1333
+ environment: Environment,
1334
+ scope?: Scope,
1335
+ ) => {
1336
+ const run: Run = {
1337
+ environment,
1338
+ isInit: false,
1339
+ isEnabled: false,
1340
+ current: state,
1341
+ isStopped: false,
1342
+ generator: undefined,
1343
+ successors: 0,
1344
+ };
1345
+ getRunner(expression, environment, false)(
1346
+ run,
1347
+ scope,
1348
+ getEmptyState(environment),
1349
+ undefined,
1350
+ false,
1351
+ (partial) => {
1352
+ if (!isComplete(partial)) run.isStopped = true;
1353
+ },
1354
+ );
1355
+ return run.isStopped;
1187
1356
  };
1188
1357
 
1189
1358
  export const getSuccessors = (