tla-ts 0.0.9 → 0.0.10-dev.06b481ee0

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 (631) hide show
  1. package/README.md +30 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +48 -44
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +122 -12
  8. package/dist/index.d.ts +122 -12
  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 +2746 -410
  15. package/dist/prove.js +2745 -409
  16. package/dist/run.cjs +144 -31
  17. package/dist/run.js +144 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +134 -104
  21. package/dist/transfer.js +134 -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 +56 -60
  26. package/src/bags.ts +128 -110
  27. package/src/builtins.ts +31 -77
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check-failure.ts +118 -0
  30. package/src/check-trace.ts +320 -0
  31. package/src/check.ts +1156 -888
  32. package/src/cli/options.ts +12 -32
  33. package/src/cli/run.ts +0 -2
  34. package/src/cli/runtime-invariants.ts +100 -0
  35. package/src/cli/shared.ts +19 -12
  36. package/src/cli/tlapm.ts +433 -82
  37. package/src/cli/tlc-arguments.ts +652 -0
  38. package/src/cli/tlc-output.ts +701 -0
  39. package/src/cli/tlc-usage.ts +360 -0
  40. package/src/cli/tlc.ts +330 -659
  41. package/src/cli/typescript.ts +23 -0
  42. package/src/cli/xml-exporter.ts +27 -49
  43. package/src/cli.ts +0 -1
  44. package/src/codegen.ts +217 -82
  45. package/src/config.ts +140 -109
  46. package/src/coverage.ts +1019 -0
  47. package/src/dependencies.ts +101 -66
  48. package/src/dfid.ts +683 -0
  49. package/src/environment-config.ts +315 -0
  50. package/src/environment.ts +263 -370
  51. package/src/errors.ts +107 -57
  52. package/src/evaluate.ts +898 -369
  53. package/src/exit-codes.ts +63 -13
  54. package/src/fingerprints.ts +75 -11
  55. package/src/index.ts +3 -0
  56. package/src/instances.ts +137 -22
  57. package/src/java-hash.ts +21 -0
  58. package/src/java-overrides.ts +6 -21
  59. package/src/json-reader.ts +455 -0
  60. package/src/json.ts +252 -139
  61. package/src/levels.ts +231 -154
  62. package/src/lexer.ts +83 -101
  63. package/src/liveness-checker.ts +743 -322
  64. package/src/liveness.ts +230 -133
  65. package/src/obligations/action.ts +17 -44
  66. package/src/obligations/anonymize.ts +120 -95
  67. package/src/obligations/enabled-axioms.ts +218 -0
  68. package/src/obligations/equality.ts +1 -3
  69. package/src/obligations/expression.ts +37 -26
  70. package/src/obligations/format.ts +0 -10
  71. package/src/obligations/generate.ts +66 -64
  72. package/src/obligations/index.ts +39 -20
  73. package/src/obligations/levels.ts +27 -18
  74. package/src/obligations/module.ts +28 -55
  75. package/src/obligations/normalize.ts +31 -41
  76. package/src/obligations/operators.ts +0 -3
  77. package/src/obligations/pragma.ts +52 -24
  78. package/src/obligations/printer.ts +94 -63
  79. package/src/obligations/proof.ts +3 -6
  80. package/src/obligations/regroup.ts +0 -5
  81. package/src/obligations/simplify.ts +57 -63
  82. package/src/obligations/source.ts +121 -95
  83. package/src/obligations/subexpression.ts +49 -28
  84. package/src/obligations/substitution.ts +1 -5
  85. package/src/obligations/temporal.ts +12 -20
  86. package/src/obligations/tuples.ts +2 -10
  87. package/src/parallel-worker.ts +36 -60
  88. package/src/parallel.ts +64 -73
  89. package/src/parser.ts +1184 -531
  90. package/src/pcal/ast.ts +53 -86
  91. package/src/pcal/parse.ts +144 -219
  92. package/src/pcal/tokenize.ts +91 -131
  93. package/src/pcal/translate.ts +83 -130
  94. package/src/pcal/validate.ts +48 -68
  95. package/src/pretty-print.ts +7 -8
  96. package/src/prover/decide-pool.ts +8 -13
  97. package/src/prover/deciders.ts +12 -13
  98. package/src/prover/first-order.ts +0 -11
  99. package/src/prover/isabelle/decide.ts +3 -31
  100. package/src/prover/isabelle/encode.ts +82 -64
  101. package/src/prover/isabelle/isar/attrib.ts +250 -0
  102. package/src/prover/isabelle/isar/context.ts +335 -0
  103. package/src/prover/isabelle/isar/induct.ts +382 -0
  104. package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
  105. package/src/prover/isabelle/isar/method.ts +510 -226
  106. package/src/prover/isabelle/isar/proof.ts +570 -23
  107. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  108. package/src/prover/isabelle/isar/theory.ts +488 -88
  109. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  110. package/src/prover/isabelle/isar/type-check.ts +99 -38
  111. package/src/prover/isabelle/provers/blast/blast.ts +16 -105
  112. package/src/prover/isabelle/provers/blast/branch.ts +0 -33
  113. package/src/prover/isabelle/provers/blast/prove.ts +0 -36
  114. package/src/prover/isabelle/provers/blast/rules.ts +5 -45
  115. package/src/prover/isabelle/provers/blast/state.ts +1 -29
  116. package/src/prover/isabelle/provers/blast/term.ts +8 -37
  117. package/src/prover/isabelle/provers/clasimp.ts +1 -15
  118. package/src/prover/isabelle/provers/classical.ts +58 -61
  119. package/src/prover/isabelle/provers/hypsubst.ts +29 -54
  120. package/src/prover/isabelle/pure/bicompose.ts +24 -39
  121. package/src/prover/isabelle/pure/consts.ts +0 -8
  122. package/src/prover/isabelle/pure/conv.ts +2 -18
  123. package/src/prover/isabelle/pure/drule.ts +95 -45
  124. package/src/prover/isabelle/pure/envir.ts +2 -53
  125. package/src/prover/isabelle/pure/goal.ts +1 -9
  126. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  127. package/src/prover/isabelle/pure/list.ts +0 -3
  128. package/src/prover/isabelle/pure/logic.ts +1 -16
  129. package/src/prover/isabelle/pure/name.ts +1 -10
  130. package/src/prover/isabelle/pure/net.ts +2 -60
  131. package/src/prover/isabelle/pure/object-logic.ts +15 -16
  132. package/src/prover/isabelle/pure/pattern.ts +1 -20
  133. package/src/prover/isabelle/pure/raw-simplifier.ts +16 -63
  134. package/src/prover/isabelle/pure/rewriter.ts +34 -77
  135. package/src/prover/isabelle/pure/search.ts +2 -11
  136. package/src/prover/isabelle/pure/seq.ts +0 -11
  137. package/src/prover/isabelle/pure/simplifier.ts +27 -16
  138. package/src/prover/isabelle/pure/table.ts +2 -33
  139. package/src/prover/isabelle/pure/tactic.ts +11 -23
  140. package/src/prover/isabelle/pure/tactical.ts +47 -48
  141. package/src/prover/isabelle/pure/term-ord.ts +1 -7
  142. package/src/prover/isabelle/pure/term.ts +4 -47
  143. package/src/prover/isabelle/pure/thm.ts +26 -48
  144. package/src/prover/isabelle/pure/type.ts +1 -16
  145. package/src/prover/isabelle/pure/unify.ts +19 -31
  146. package/src/prover/isabelle/pure/variable.ts +2 -8
  147. package/src/prover/isabelle/tla/classical-setup.ts +17 -25
  148. package/src/prover/isabelle/tla/context.ts +65 -26
  149. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  150. package/src/prover/isabelle/tla/logic.ts +53 -32
  151. package/src/prover/isabelle/tla/simpdata.ts +45 -44
  152. package/src/prover/isabelle/tools/intuitionistic.ts +28 -21
  153. package/src/prover/ocaml.ts +4 -7
  154. package/src/prover/prep/action.ts +33 -66
  155. package/src/prover/prep/enabled-axioms.ts +22 -20
  156. package/src/prover/prep/fingerprint.ts +2 -21
  157. package/src/prover/prep/level-comparison.ts +8 -12
  158. package/src/prover/prep/md5.ts +26 -31
  159. package/src/prover/prep/methods.ts +189 -86
  160. package/src/prover/prep/normalize.ts +42 -37
  161. package/src/prover/prove-worker.ts +0 -2
  162. package/src/prover/prove.ts +398 -133
  163. package/src/prover/ptl/decide.ts +96 -56
  164. package/src/prover/ptl/encode.ts +15 -38
  165. package/src/prover/ptl/sat.ts +24 -32
  166. package/src/prover/ptl/tableau.ts +40 -28
  167. package/src/prover/smt/arithmetic.ts +310 -0
  168. package/src/prover/smt/axioms.ts +12 -15
  169. package/src/prover/smt/context.ts +60 -32
  170. package/src/prover/smt/data.ts +517 -401
  171. package/src/prover/smt/encode.ts +155 -85
  172. package/src/prover/smt/extensionality.ts +5 -13
  173. package/src/prover/smt/flatten.ts +7 -28
  174. package/src/prover/smt/format.ts +33 -14
  175. package/src/prover/smt/instances.ts +7 -11
  176. package/src/prover/smt/layout.ts +91 -0
  177. package/src/prover/smt/rewrite.ts +1021 -658
  178. package/src/prover/smt/simplify.ts +441 -0
  179. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  180. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  181. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  182. package/src/prover/smt/solver/act-cache.ts +0 -16
  183. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  184. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  185. package/src/prover/smt/solver/aig.ts +889 -0
  186. package/src/prover/smt/solver/arith-rewriter.ts +626 -56
  187. package/src/prover/smt/solver/arith-terms.ts +121 -0
  188. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  189. package/src/prover/smt/solver/array-rewriter.ts +319 -0
  190. package/src/prover/smt/solver/array.ts +1 -3
  191. package/src/prover/smt/solver/asserted-formulas.ts +241 -99
  192. package/src/prover/smt/solver/ast-lt.ts +165 -21
  193. package/src/prover/smt/solver/ast-util.ts +160 -7
  194. package/src/prover/smt/solver/ast.ts +1480 -184
  195. package/src/prover/smt/solver/auf-solver.ts +30 -56
  196. package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
  197. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  198. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  199. package/src/prover/smt/solver/bound-manager.ts +196 -0
  200. package/src/prover/smt/solver/bound-simplifier.ts +598 -0
  201. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  202. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  203. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  204. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  205. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  206. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  207. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  208. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  209. package/src/prover/smt/solver/card2bv.ts +127 -0
  210. package/src/prover/smt/solver/case-split-queue.ts +0 -10
  211. package/src/prover/smt/solver/cg-table.ts +39 -42
  212. package/src/prover/smt/solver/check-logic.ts +330 -0
  213. package/src/prover/smt/solver/clause.ts +0 -27
  214. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
  215. package/src/prover/smt/solver/conflict-resolution.ts +78 -11
  216. package/src/prover/smt/solver/context.ts +600 -187
  217. package/src/prover/smt/solver/ctx-simplify.ts +34 -52
  218. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  219. package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
  220. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  221. package/src/prover/smt/solver/demodulator.ts +786 -0
  222. package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
  223. package/src/prover/smt/solver/der.ts +39 -30
  224. package/src/prover/smt/solver/diff-neq.ts +205 -0
  225. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  226. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  227. package/src/prover/smt/solver/dt2bv-tactic.ts +296 -0
  228. package/src/prover/smt/solver/dyn-ack.ts +0 -11
  229. package/src/prover/smt/solver/e-matching.ts +9 -41
  230. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  231. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  232. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  233. package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
  234. package/src/prover/smt/solver/enode.ts +100 -23
  235. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  236. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  237. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  238. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  239. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  240. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  241. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  242. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  243. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  244. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  245. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  246. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  247. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  248. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  249. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  250. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  251. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  252. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  253. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  254. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  255. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  256. package/src/prover/smt/solver/expr-ref.ts +0 -5
  257. package/src/prover/smt/solver/expr-safe-replace.ts +26 -7
  258. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  259. package/src/prover/smt/solver/factor.ts +163 -0
  260. package/src/prover/smt/solver/fd-solver.ts +734 -0
  261. package/src/prover/smt/solver/fingerprints.ts +15 -26
  262. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  263. package/src/prover/smt/solver/flat-literals.ts +0 -9
  264. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  265. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  266. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  267. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  268. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  269. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  270. package/src/prover/smt/solver/goal.ts +179 -28
  271. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  272. package/src/prover/smt/solver/guard-set.ts +219 -0
  273. package/src/prover/smt/solver/hash.ts +0 -9
  274. package/src/prover/smt/solver/hashtable.ts +30 -23
  275. package/src/prover/smt/solver/inf-eps.ts +63 -0
  276. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  277. package/src/prover/smt/solver/internalizer.ts +113 -133
  278. package/src/prover/smt/solver/lackr.ts +381 -0
  279. package/src/prover/smt/solver/lbool.ts +0 -2
  280. package/src/prover/smt/solver/lia2card.ts +268 -0
  281. package/src/prover/smt/solver/lia2pb.ts +154 -0
  282. package/src/prover/smt/solver/literal.ts +0 -4
  283. package/src/prover/smt/solver/logic-tactics.ts +355 -0
  284. package/src/prover/smt/solver/lp/bound-propagator.ts +7 -26
  285. package/src/prover/smt/solver/lp/constraints.ts +1 -8
  286. package/src/prover/smt/solver/lp/containers.ts +18 -31
  287. package/src/prover/smt/solver/lp/core-solver.ts +35 -37
  288. package/src/prover/smt/solver/lp/cross-nested.ts +4 -21
  289. package/src/prover/smt/solver/lp/dep-intervals.ts +6 -24
  290. package/src/prover/smt/solver/lp/dependency.ts +0 -5
  291. package/src/prover/smt/solver/lp/dioph-eq.ts +8 -103
  292. package/src/prover/smt/solver/lp/explanation.ts +0 -6
  293. package/src/prover/smt/solver/lp/gomory.ts +8 -22
  294. package/src/prover/smt/solver/lp/hnf-cutter.ts +16 -23
  295. package/src/prover/smt/solver/lp/hnf.ts +10 -28
  296. package/src/prover/smt/solver/lp/int-cube.ts +17 -39
  297. package/src/prover/smt/solver/lp/int-solver.ts +3 -35
  298. package/src/prover/smt/solver/lp/lar-solver.ts +70 -83
  299. package/src/prover/smt/solver/lp/lar-term.ts +0 -5
  300. package/src/prover/smt/solver/lp/lp-settings.ts +6 -16
  301. package/src/prover/smt/solver/lp/maximize-term.ts +76 -52
  302. package/src/prover/smt/solver/lp/nex-creator.ts +7 -30
  303. package/src/prover/smt/solver/lp/nex.ts +2 -7
  304. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -5
  305. package/src/prover/smt/solver/lp/nla-basics.ts +48 -30
  306. package/src/prover/smt/solver/lp/nla-core.ts +92 -136
  307. package/src/prover/smt/solver/lp/nla-divisions.ts +31 -43
  308. package/src/prover/smt/solver/lp/nla-emonics.ts +3 -21
  309. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -4
  310. package/src/prover/smt/solver/lp/nla-grobner.ts +177 -149
  311. package/src/prover/smt/solver/lp/nla-horner.ts +2 -12
  312. package/src/prover/smt/solver/lp/nla-intervals.ts +1 -12
  313. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +15 -42
  314. package/src/prover/smt/solver/lp/nla-monotone.ts +1 -6
  315. package/src/prover/smt/solver/lp/nla-order.ts +0 -13
  316. package/src/prover/smt/solver/lp/nla-patcher.ts +3 -7
  317. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  318. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -10
  319. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -6
  320. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  321. package/src/prover/smt/solver/lp/nla-types.ts +0 -12
  322. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -26
  323. package/src/prover/smt/solver/lp/nra-solver.ts +164 -147
  324. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -4
  325. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -5
  326. package/src/prover/smt/solver/lp/pdd-simplifier.ts +61 -34
  327. package/src/prover/smt/solver/lp/pdd-solver.ts +74 -72
  328. package/src/prover/smt/solver/lp/pdd.ts +730 -358
  329. package/src/prover/smt/solver/lp/random-updater.ts +0 -9
  330. package/src/prover/smt/solver/lp/static-matrix.ts +8 -19
  331. package/src/prover/smt/solver/lp/union-find.ts +5 -5
  332. package/src/prover/smt/solver/macro-finder.ts +530 -0
  333. package/src/prover/smt/solver/mam-compiler.ts +129 -139
  334. package/src/prover/smt/solver/mam-interpreter.ts +0 -21
  335. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  336. package/src/prover/smt/solver/max-cliques.ts +105 -0
  337. package/src/prover/smt/solver/maxcore.ts +310 -0
  338. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -21
  339. package/src/prover/smt/solver/maxlex.ts +115 -0
  340. package/src/prover/smt/solver/maxsmt-base.ts +106 -0
  341. package/src/prover/smt/solver/maxsmt.ts +92 -0
  342. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  343. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  344. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  345. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  346. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  347. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  348. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  349. package/src/prover/smt/solver/model-checker.ts +20 -63
  350. package/src/prover/smt/solver/model-evaluator.ts +192 -40
  351. package/src/prover/smt/solver/model-finder.ts +14 -32
  352. package/src/prover/smt/solver/model-generator.ts +104 -46
  353. package/src/prover/smt/solver/model-macro-solver.ts +60 -114
  354. package/src/prover/smt/solver/model-printer.ts +214 -0
  355. package/src/prover/smt/solver/mpf.ts +709 -0
  356. package/src/prover/smt/solver/mus.ts +50 -0
  357. package/src/prover/smt/solver/muz/dl-context.ts +382 -0
  358. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  359. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  360. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  361. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  362. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  363. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  364. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  365. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  366. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  367. package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
  368. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  369. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  370. package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
  371. package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
  372. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  373. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  374. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  375. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  376. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  377. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  378. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  379. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  380. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  381. package/src/prover/smt/solver/nlqsat.ts +484 -0
  382. package/src/prover/smt/solver/nlsat/algebraic.ts +357 -236
  383. package/src/prover/smt/solver/nlsat/atoms.ts +73 -54
  384. package/src/prover/smt/solver/nlsat/evaluator.ts +16 -22
  385. package/src/prover/smt/solver/nlsat/explain.ts +429 -275
  386. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -51
  387. package/src/prover/smt/solver/nlsat/levelwise.ts +477 -344
  388. package/src/prover/smt/solver/nlsat/mpbq.ts +47 -14
  389. package/src/prover/smt/solver/nlsat/polynomial.ts +2385 -832
  390. package/src/prover/smt/solver/nlsat/solver.ts +297 -156
  391. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  392. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  393. package/src/prover/smt/solver/nlsat/types.ts +0 -9
  394. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -51
  395. package/src/prover/smt/solver/nlsat/upolynomial.ts +49 -109
  396. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  397. package/src/prover/smt/solver/nnf.ts +112 -61
  398. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  399. package/src/prover/smt/solver/occf.ts +97 -0
  400. package/src/prover/smt/solver/opt-context.ts +801 -0
  401. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  402. package/src/prover/smt/solver/opt-pareto.ts +301 -0
  403. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  404. package/src/prover/smt/solver/opt-solver.ts +312 -0
  405. package/src/prover/smt/solver/opt-value.ts +55 -0
  406. package/src/prover/smt/solver/optsmt.ts +692 -0
  407. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  408. package/src/prover/smt/solver/pattern-inference.ts +21 -26
  409. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  410. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  411. package/src/prover/smt/solver/poly-rewriter.ts +261 -79
  412. package/src/prover/smt/solver/probes.ts +577 -0
  413. package/src/prover/smt/solver/propagate-values.ts +37 -30
  414. package/src/prover/smt/solver/proto-model.ts +650 -66
  415. package/src/prover/smt/solver/pull-quant.ts +28 -23
  416. package/src/prover/smt/solver/purify-arith.ts +632 -0
  417. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  418. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  419. package/src/prover/smt/solver/qe-lite-der.ts +2 -31
  420. package/src/prover/smt/solver/qe-lite-fm.ts +4 -28
  421. package/src/prover/smt/solver/qe-lite.ts +41 -51
  422. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  423. package/src/prover/smt/solver/qe.ts +1499 -0
  424. package/src/prover/smt/solver/qel.ts +25 -0
  425. package/src/prover/smt/solver/qi-queue.ts +0 -16
  426. package/src/prover/smt/solver/qsat.ts +829 -0
  427. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  428. package/src/prover/smt/solver/quant-tactics.ts +17 -74
  429. package/src/prover/smt/solver/quantifier-analyzer.ts +26 -47
  430. package/src/prover/smt/solver/quantifier-manager.ts +22 -32
  431. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  432. package/src/prover/smt/solver/random-gen.ts +0 -2
  433. package/src/prover/smt/solver/rational.ts +45 -8
  434. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  435. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  436. package/src/prover/smt/solver/reduce-args.ts +225 -0
  437. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  438. package/src/prover/smt/solver/ref-vector.ts +0 -6
  439. package/src/prover/smt/solver/relevancy.ts +2 -16
  440. package/src/prover/smt/solver/rewriter-tpl.ts +59 -135
  441. package/src/prover/smt/solver/rewriter.ts +507 -144
  442. package/src/prover/smt/solver/rlimit.ts +46 -24
  443. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  444. package/src/prover/smt/solver/sat/big.ts +177 -0
  445. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  446. package/src/prover/smt/solver/sat/clause.ts +203 -0
  447. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  448. package/src/prover/smt/solver/sat/config.ts +122 -0
  449. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  450. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  451. package/src/prover/smt/solver/sat/goal2sat.ts +579 -0
  452. package/src/prover/smt/solver/sat/inc-sat-solver.ts +464 -0
  453. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  454. package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
  455. package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
  456. package/src/prover/smt/solver/sat/probing.ts +170 -0
  457. package/src/prover/smt/solver/sat/sat-tactic.ts +53 -0
  458. package/src/prover/smt/solver/sat/sat2goal.ts +189 -0
  459. package/src/prover/smt/solver/sat/scc.ts +142 -0
  460. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  461. package/src/prover/smt/solver/sat/solver.ts +2107 -0
  462. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  463. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  464. package/src/prover/smt/solver/search-tree.ts +284 -0
  465. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  466. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  467. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  468. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  469. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  470. package/src/prover/smt/solver/seq-factory.ts +89 -0
  471. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  472. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  473. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  474. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  475. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  476. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  477. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  478. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  479. package/src/prover/smt/solver/seq-subset.ts +165 -0
  480. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  481. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  482. package/src/prover/smt/solver/smt-kernel.ts +124 -0
  483. package/src/prover/smt/solver/smt-logics.ts +66 -0
  484. package/src/prover/smt/solver/smt-setup.ts +589 -0
  485. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  486. package/src/prover/smt/solver/smtlib-parser.ts +3546 -406
  487. package/src/prover/smt/solver/smtlib-script.ts +2134 -0
  488. package/src/prover/smt/solver/solve-eqs.ts +928 -0
  489. package/src/prover/smt/solver/solver.ts +135 -40
  490. package/src/prover/smt/solver/sort.ts +1 -5
  491. package/src/prover/smt/solver/static-features.ts +314 -0
  492. package/src/prover/smt/solver/sticky-generations.ts +0 -6
  493. package/src/prover/smt/solver/tactic.ts +2141 -0
  494. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  495. package/src/prover/smt/solver/theory-array.ts +1240 -0
  496. package/src/prover/smt/solver/theory-bv.ts +1210 -0
  497. package/src/prover/smt/solver/theory-char.ts +355 -0
  498. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  499. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  500. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  501. package/src/prover/smt/solver/theory-lra-axioms.ts +55 -25
  502. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -11
  503. package/src/prover/smt/solver/theory-lra-final-check.ts +60 -91
  504. package/src/prover/smt/solver/theory-lra-internalize.ts +96 -53
  505. package/src/prover/smt/solver/theory-lra-model.ts +23 -53
  506. package/src/prover/smt/solver/theory-lra-propagate.ts +34 -42
  507. package/src/prover/smt/solver/theory-lra-state.ts +7 -28
  508. package/src/prover/smt/solver/theory-lra.ts +189 -9
  509. package/src/prover/smt/solver/theory-pb.ts +951 -0
  510. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  511. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  512. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  513. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  514. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  515. package/src/prover/smt/solver/theory-seq.ts +961 -0
  516. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  517. package/src/prover/smt/solver/theory.ts +189 -0
  518. package/src/prover/smt/solver/tseitin-cnf.ts +486 -0
  519. package/src/prover/smt/solver/var-subst.ts +37 -39
  520. package/src/prover/smt/table.ts +3 -10
  521. package/src/prover/smt/types.ts +146 -0
  522. package/src/prover/tlapm/cache.ts +74 -48
  523. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  524. package/src/prover/tlapm/tlapm.ts +21 -20
  525. package/src/prover/tlapm-library.ts +3208 -0
  526. package/src/prover/verdict.ts +9 -2
  527. package/src/prover/zenon/check/check.ts +1 -11
  528. package/src/prover/zenon/check/definitions.ts +5 -15
  529. package/src/prover/zenon/check/equality.ts +0 -8
  530. package/src/prover/zenon/check/functions.ts +0 -4
  531. package/src/prover/zenon/check/keys.ts +0 -7
  532. package/src/prover/zenon/check/propositional.ts +0 -3
  533. package/src/prover/zenon/check/records.ts +1 -6
  534. package/src/prover/zenon/check/relations.ts +2 -14
  535. package/src/prover/zenon/check/rewrites.ts +2 -21
  536. package/src/prover/zenon/check/sets.ts +40 -61
  537. package/src/prover/zenon/check/terms.ts +1 -19
  538. package/src/prover/zenon/check/tla.ts +0 -6
  539. package/src/prover/zenon/decide.ts +10 -19
  540. package/src/prover/zenon/encode.ts +0 -9
  541. package/src/prover/zenon/eqrel.ts +2 -15
  542. package/src/prover/zenon/equality-rules.ts +24 -6
  543. package/src/prover/zenon/expr.ts +29 -28
  544. package/src/prover/zenon/index-table.ts +33 -61
  545. package/src/prover/zenon/isar-case.ts +9 -21
  546. package/src/prover/zenon/isar.ts +37 -67
  547. package/src/prover/zenon/limits.ts +0 -4
  548. package/src/prover/zenon/llproof.ts +2 -22
  549. package/src/prover/zenon/mltoll.ts +66 -106
  550. package/src/prover/zenon/node.ts +20 -15
  551. package/src/prover/zenon/ocaml.ts +1 -17
  552. package/src/prover/zenon/parse.ts +9 -13
  553. package/src/prover/zenon/phrase.ts +2 -14
  554. package/src/prover/zenon/proof.ts +0 -11
  555. package/src/prover/zenon/propositional-rules.ts +0 -7
  556. package/src/prover/zenon/rules.ts +3 -8
  557. package/src/prover/zenon/search.ts +11 -35
  558. package/src/prover/zenon/tla/functions.ts +59 -33
  559. package/src/prover/zenon/tla/llproof.ts +67 -78
  560. package/src/prover/zenon/tla/records.ts +57 -35
  561. package/src/prover/zenon/tla/rewrites.ts +12 -21
  562. package/src/prover/zenon/tla/sets.ts +88 -59
  563. package/src/prover/zenon/tla/terms.ts +0 -8
  564. package/src/prover/zenon/tla/tla.ts +66 -66
  565. package/src/randomization.ts +81 -35
  566. package/src/resolve.ts +1132 -430
  567. package/src/runtime.ts +33 -23
  568. package/src/sany/builtins.ts +11 -14
  569. package/src/sany/generation.ts +383 -0
  570. package/src/sany/generator-def-entries.ts +210 -0
  571. package/src/sany/generator-definitions.ts +688 -0
  572. package/src/sany/generator-expressions.ts +1108 -0
  573. package/src/sany/generator-proofs.ts +665 -0
  574. package/src/sany/generator.ts +192 -2764
  575. package/src/sany/levels.ts +5 -35
  576. package/src/sany/lexer.ts +61 -80
  577. package/src/sany/linter.ts +0 -10
  578. package/src/sany/modules.ts +5 -7
  579. package/src/sany/nodes.ts +6 -44
  580. package/src/sany/parse-error.ts +39 -117
  581. package/src/sany/report.ts +32 -69
  582. package/src/sany/selectors.ts +60 -82
  583. package/src/sany/source.ts +1 -17
  584. package/src/sany/xml.ts +37 -120
  585. package/src/search.ts +913 -227
  586. package/src/simulate.ts +765 -0
  587. package/src/spec-description.ts +198 -104
  588. package/src/standard-definitions.ts +4 -4
  589. package/src/standard-modules.ts +302 -99
  590. package/src/state-graph.ts +52 -33
  591. package/src/subexpressions.ts +578 -166
  592. package/src/substitution-levels.ts +7 -7
  593. package/src/successors.ts +299 -108
  594. package/src/symmetry.ts +37 -28
  595. package/src/tableau.ts +29 -26
  596. package/src/tlc/fingerprint.ts +267 -79
  597. package/src/tlc/jar-data.ts +122 -6
  598. package/src/tlc/messages.ts +127 -56
  599. package/src/tlc/order.ts +53 -72
  600. package/src/tlc/random.ts +38 -49
  601. package/src/tlc/replay.ts +579 -230
  602. package/src/tlc/summary.ts +64 -60
  603. package/src/tlc/tlc-operators.ts +83 -47
  604. package/src/tlc/tlcext-operators.ts +205 -127
  605. package/src/tlc/trace-spec.ts +235 -0
  606. package/src/tlc/value-stream.ts +139 -0
  607. package/src/tlc/version.ts +1 -4
  608. package/src/trace-liveness.ts +529 -0
  609. package/src/transfer.ts +22 -25
  610. package/src/typed-tier.ts +6556 -0
  611. package/src/typescript/actions.ts +479 -0
  612. package/src/typescript/collections.ts +614 -0
  613. package/src/typescript/compile.ts +63 -0
  614. package/src/typescript/context.ts +94 -0
  615. package/src/typescript/emit.ts +121 -0
  616. package/src/typescript/expressions.ts +496 -0
  617. package/src/typescript/formula.ts +154 -0
  618. package/src/typescript/functions.ts +284 -0
  619. package/src/typescript/model.ts +162 -0
  620. package/src/typescript/names.ts +114 -0
  621. package/src/typescript/program.ts +48 -0
  622. package/src/typescript/properties.ts +139 -0
  623. package/src/typescript/scope.ts +112 -0
  624. package/src/typescript/steps.ts +167 -0
  625. package/src/typescript/types.ts +171 -0
  626. package/src/values.ts +945 -526
  627. package/src/worker.ts +7 -8
  628. package/src/prover/isabelle/isar/statement.ts +0 -57
  629. package/src/prover/smt/solver/z3-license.txt +0 -10
  630. package/src/prover/tlaps-module.ts +0 -510
  631. package/src/prover/zenon/LICENSE +0 -32
package/src/evaluate.ts CHANGED
@@ -1,5 +1,6 @@
1
1
  import {
2
2
  getChildren,
3
+ getReferencedName,
3
4
  isLocallyResolved,
4
5
  type Bound,
5
6
  type BoundPattern,
@@ -10,21 +11,41 @@ import {
10
11
  type NumberExpression,
11
12
  type OperatorParam,
12
13
  type RecordField,
13
- type SourceRange,
14
14
  } from "./ast";
15
15
  import { getKindString } from "./builtins";
16
- import { isStackOverflow, TlaEvaluationError, TlaUnassignedError } from "./errors";
16
+ import {
17
+ isStackOverflow,
18
+ TlaEvaluationError,
19
+ TlaSetBoundError,
20
+ TlaUnassignedError,
21
+ formatRange,
22
+ } from "./errors";
17
23
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
18
24
  import { generateEvaluator } from "./codegen";
25
+ import {
26
+ chargeContexts,
27
+ chargeFunctionConstruction,
28
+ chargeSetOperation,
29
+ costCoverage,
30
+ countCoverage,
31
+ createChargedEnumerator,
32
+ createProductSetEnumerator,
33
+ getCoverageNode,
34
+ runAtCoverageNode,
35
+ tagSubset,
36
+ type Coverage,
37
+ } from "./coverage";
19
38
  import { MESSAGE_CODE } from "./tlc/messages";
20
39
  import type { CheckerRuntime } from "./runtime";
21
40
  import {
22
- isConstantLevel,
41
+ isEvaluatedAtStartup,
42
+ isExpressionImpure,
23
43
  isImpureDefinition,
24
44
  isNonconstant,
45
+ isTlcEvalReached,
25
46
  type DefinitionFacts,
26
47
  } from "./dependencies";
27
- import { contextualApplications } from "./instances";
48
+ import { contextualApplications, substitutionFrames } from "./instances";
28
49
  import { prettyPrint } from "./pretty-print";
29
50
  import { isEnabled } from "./successors";
30
51
  import {
@@ -32,12 +53,15 @@ import {
32
53
  describeMissingArgument,
33
54
  compareValues,
34
55
  createFunction,
56
+ addBoundedElement,
35
57
  createNonIntegerKeyError,
58
+ forEachElement,
59
+ isBeyondSetBound,
36
60
  createRecord,
37
61
  createEnumeratedSet,
38
62
  createSortedFunction,
39
63
  createSortedRecord,
40
- createSortedSet,
64
+ createNormalizedSet,
41
65
  createWrittenRecord,
42
66
  createTuple,
43
67
  formatValue,
@@ -47,6 +71,7 @@ import {
47
71
  getIntervalElements,
48
72
  getLazySubsets,
49
73
  getStreamedElements,
74
+ normalizeShallowly,
50
75
  getFunctionClass,
51
76
  getNormalizedSetElements,
52
77
  getSequenceElements,
@@ -81,7 +106,6 @@ export interface OperatorValue {
81
106
  arity: number;
82
107
  call: (args: Value[]) => Value;
83
108
  expression?: Expression;
84
- literalBody?: Value;
85
109
  }
86
110
 
87
111
  export type BuiltinArgument = Value | OperatorValue;
@@ -94,8 +118,8 @@ export interface Builtin {
94
118
  evaluateUnary: ((value: Value) => Value) | undefined;
95
119
  evaluateBinary: ((left: Value, right: Value) => Value) | undefined;
96
120
  isStateLevel?: boolean;
97
- // Whether TLC takes an application for a constant one although its value depends on the state.
98
121
  isLevelConstant?: boolean;
122
+ isActionLevel?: boolean;
99
123
  isLazy?: boolean;
100
124
  }
101
125
 
@@ -116,12 +140,14 @@ export interface Thunk {
116
140
  state: State | undefined;
117
141
  next: State | undefined;
118
142
  cache: Value | undefined;
119
- // Whether the expression may build a set that streams until TLC caches it, so that the thunk
120
- // caches only a settled value.
121
143
  isStreamed: boolean;
144
+ isReleased?: boolean;
122
145
  }
123
146
 
124
- type Binding = { kind: "Value"; value: Value } | Thunk | { kind: "Operator"; operator: Operator };
147
+ type Binding =
148
+ | { kind: "Value"; value: Value; argument?: Expression }
149
+ | Thunk
150
+ | { kind: "Operator"; operator: Operator };
125
151
 
126
152
  export interface Scope {
127
153
  name: string;
@@ -135,55 +161,37 @@ export interface Environment {
135
161
  builtins: Map<string, Builtin>;
136
162
  constants: Map<string, Value>;
137
163
  substitutions: Map<string, string>;
138
- // The name SANY gives each definition that a named instance such as `M == INSTANCE Module`
139
- // copies, such as M!Op, by the key of the copy.
140
164
  instanceNames: Map<string, string>;
141
165
  variables: string[];
142
166
  variableIndex: Map<string, number>;
143
167
  facts: DefinitionFacts;
144
- // The value of each constant definition TLC computed when it started, by the definition's id in
145
- // facts. TLC evaluates a definition it failed to compute where the spec uses it.
146
168
  startupValues: (Value | undefined)[];
147
- // The definitions an INSTANCE copies from a module that declares constants or variables. SANY
148
- // wraps the body of each in its substitutions.
169
+ tlcEvalValues: WeakMap<Expression, Value>;
149
170
  substitutedDefinitions: Set<Definition>;
150
- // The compiled code of each expression, of each expression evaluated as a whole, which generated
151
- // code can serve, and of each reference to a definition.
171
+ instanceParams: Set<OperatorParam>;
152
172
  evaluators: WeakMap<Expression, Evaluator>;
153
173
  entryEvaluators: WeakMap<Expression, Evaluator>;
154
174
  definitionEvaluators: WeakMap<Definition, Evaluator>;
155
- // The expressions being evaluated, outermost first, when the environment replays an error to
156
- // find where it occurred, as TLC's CallStackTool does.
157
175
  callStack?: CallStack;
176
+ coverage?: Coverage;
158
177
  }
159
178
 
160
179
  export interface CallStack {
161
180
  expressions: Expression[];
162
- // TLC stops popping the stack once an evaluation fails, so it keeps where the failure occurred.
163
181
  isFrozen: boolean;
164
- // The expression that built each value of the replay that TLC's CallStackTool gives a source.
165
182
  sources: WeakMap<ObjectValue, Expression>;
166
- // The value each expression of the replay last evaluated to.
167
183
  values: WeakMap<Expression, Value>;
168
- // The expression each failure last left, which tells a failure of an operand from one of the
169
- // method that computes the operator.
170
184
  failures: WeakMap<Error, Expression>;
171
- // The failure of a value with a source, which TLC raises as a FingerprintException.
172
185
  fingerprint?: FingerprintFailure;
173
186
  }
174
187
 
175
188
  export interface FingerprintFailure {
176
- // The sources of the values whose methods failed, outermost first.
177
189
  sources: Expression[];
178
- // The message of the error the innermost one raised.
179
190
  reason: string;
180
191
  }
181
192
 
182
- // The operators of Tool#evalAppl whose value TLC's CallStackTool gives a source.
183
193
  const SOURCED_OPERATORS = new Set(["SUBSET", "UNION", "DOMAIN", "\\cup", "\\cap", "\\"]);
184
194
 
185
- // CallStackTool copies the SetPredValue, FcnLambdaValue and OpLambdaValue that an evaluation
186
- // returns without their source, and a function TLC builds from a FcnLambdaValue has none.
187
195
  const SOURCED_KINDS = new Set<Expression["kind"]>([
188
196
  "SetEnumeration",
189
197
  "SetFilter",
@@ -199,8 +207,6 @@ const isSourced = (expression: Expression) =>
199
207
  SOURCED_KINDS.has(expression.kind) ||
200
208
  (expression.kind === "Apply" && SOURCED_OPERATORS.has(expression.operator));
201
209
 
202
- // The argument whose method Tool#evalAppl calls to compute an operator, as with S.member(e) for
203
- // e \in S, f.apply(e) for f[e] when f is a function, or S.diff(T) for S \ T when S is Reducible.
204
210
  const getReceiver = (expression: Expression, values: CallStack["values"]) => {
205
211
  if (expression.kind === "FunctionApplication" || expression.kind === "Except") {
206
212
  return expression.function;
@@ -221,8 +227,6 @@ export interface Context {
221
227
  scope: Scope | undefined;
222
228
  state: State | undefined;
223
229
  next: State | undefined;
224
- // EvalControl.KeepLazy, which Tool#evalAppl sets to evaluate the function it applies and which
225
- // the evaluation passes on, so that a function constructor within builds a FcnLambdaValue.
226
230
  isKeepLazy?: boolean;
227
231
  }
228
232
 
@@ -246,15 +250,23 @@ const EXCEPT_AT = "@";
246
250
  export const describeLocation = (expression: Expression) =>
247
251
  `line ${expression.location.line}, column ${expression.location.column}`;
248
252
 
249
- export const formatRange = (range: SourceRange) =>
250
- `line ${range.start.line}, col ${range.start.column} to line ${range.end.line}, col ${range.end.column} of module ${range.module}`;
251
-
252
253
  export const describeRange = (expression: Expression) => {
253
254
  const range = expression.location.range;
254
255
  return range ? formatRange(range) : describeLocation(expression);
255
256
  };
256
257
 
257
- // SANY prints a numeral as written and any other expression by its location.
258
+ const TEMPORAL_FORMS = {
259
+ Always: "[]A",
260
+ Eventually: "<>A",
261
+ WeakFairness: "WF",
262
+ StrongFairness: "SF",
263
+ };
264
+
265
+ const createTemporalFormulaError = (form: string, expression: Expression) =>
266
+ new TlaEvaluationError(
267
+ `TLC encountered a temporal formula (${form}) when evaluating a predicate or action.\n${describeRange(expression)}`,
268
+ );
269
+
258
270
  export const describeNode = (expression: Expression) =>
259
271
  expression.kind === "Number"
260
272
  ? (expression.text ?? String(expression.value))
@@ -265,8 +277,6 @@ export const createConditionError = (expression: Expression, value: Value) =>
265
277
  `A non-boolean expression (${getKindString(value)}) was used as the condition of an IF.\n${describeRange(expression)}`,
266
278
  );
267
279
 
268
- // TLC parses an infix chain of /\ or \/ as nested binary junctions and a bulleted list as one
269
- // junction list, and it words the error differently for each.
270
280
  export const createJunctionError = (
271
281
  expression: Expression & { kind: "And" | "Or" },
272
282
  index: number,
@@ -287,12 +297,10 @@ export const createJunctionError = (
287
297
  );
288
298
  };
289
299
 
290
- // TLC selects a field of a record, and of another function from the function it converts it to,
291
- // which for a tuple keeps its domain as an interval.
292
300
  export const getFieldSelector = (expression: Expression & { kind: "FieldAccess" }) => {
293
301
  const field = expression.field;
294
302
  const describeMissing = (record: Value) =>
295
- `Attempted to select nonexistent field "${field}" from the record\n${formatValue(record)}\n${describeRange(expression)}`;
303
+ `Attempted to select nonexistent field "${field}" from the record\n${prettyPrint(formatValue(record))}\n${describeRange(expression)}`;
296
304
  const describeNotInDomain = (functionValue: Value) =>
297
305
  `Attempted to apply function:\n${prettyPrint(formatValue(functionValue))}\nto argument "${field}", which is not in the domain of the function.`;
298
306
  return (value: Value) => {
@@ -303,17 +311,14 @@ export const getFieldSelector = (expression: Expression & { kind: "FieldAccess"
303
311
  }
304
312
  const functionClass = getFunctionClass(value);
305
313
  if (functionClass === "tuple") throw createNonIntegerKeyError(field);
306
- // Only TLC's RecordValue names the field it lacks. Any other function, such as a FcnRcdValue
307
- // whose keys are strings, reports an argument outside its domain.
308
314
  return applyFunction(
309
- value,
315
+ value.kind === "LazyFunction" ? toFiniteFunction(value) : value,
310
316
  field,
311
317
  functionClass === "record" ? describeMissing : describeNotInDomain,
312
318
  );
313
319
  };
314
320
  };
315
321
 
316
- // TLC 1.7.4 words what a tuple or a record lacks differently.
317
322
  export const getMissingArgumentDescriber = (version: TlcVersion | undefined) =>
318
323
  version === "1.7.4"
319
324
  ? (functionValue: Value, argument: Value) =>
@@ -330,41 +335,36 @@ export const getDomainOperator = (expression: Expression) => (value: Value) => {
330
335
  };
331
336
 
332
337
  export const getSubsetOperator =
333
- (expression: Expression, builtin: Builtin) => (left: Value, right: Value) => {
338
+ (expression: Expression, subset: (left: Value, right: Value) => Value) =>
339
+ (left: Value, right: Value) => {
334
340
  if (!isSetValue(left) || isOverriddenSet(left)) {
335
341
  throw new TlaEvaluationError(
336
342
  `Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
337
343
  );
338
344
  }
339
- return builtin.evaluate([left, right]);
345
+ return subset(left, right);
340
346
  };
341
347
 
342
- // TLC rejects a decimal, or an integer literal too big for it, while it processes the spec.
343
348
  export const createRealNumberError = (expression: DecimalExpression) =>
344
349
  setExitCode(
345
- new TlaEvaluationError(
346
- `TLC can't handle real numbers: ${expression.text} at ${describeLocation(expression)}`,
347
- ),
350
+ new TlaEvaluationError(`TLC can't handle real numbers.\n${expression.text}`),
348
351
  EXIT_STATUS.configParseError,
349
352
  );
350
353
 
351
354
  export const createBigNumberError = (expression: NumberExpression) =>
352
355
  setExitCode(
353
356
  new TlaEvaluationError(
354
- `TLC can't handle a number this big: ${expression.text ?? expression.value} at ${describeLocation(expression)}`,
357
+ `TLC can't handle a number this big.\n${expression.text ?? expression.value}`,
355
358
  ),
356
359
  EXIT_STATUS.error,
357
360
  );
358
361
 
359
- // TLC's Tool#evalAppl fails to look up a variable the state doesn't assign.
360
362
  export const createUnassignedError = (name: string, expression: Expression) =>
361
363
  new TlaUnassignedError(
362
364
  `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
363
365
  name,
364
366
  );
365
367
 
366
- // TLC's Tool#enabled reads the subscript of <<A>>_v in the successor as a state of its own, and
367
- // names the fairness condition when A leaves a variable of v unassigned, unlike TLC 1.7.4's.
368
368
  export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion | undefined) =>
369
369
  error instanceof TlaUnassignedError && version !== "1.7.4"
370
370
  ? new TlaEvaluationError(
@@ -372,11 +372,6 @@ export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion
372
372
  )
373
373
  : error;
374
374
 
375
- export const createPrimeOutsideActionError = (expression: Expression) =>
376
- new TlaEvaluationError(
377
- `A primed expression appears outside an action at ${describeLocation(expression)}`,
378
- );
379
-
380
375
  export const lookupScope = (scope: Scope | undefined, name: string): Binding | undefined => {
381
376
  for (let current = scope; current; current = current.parent) {
382
377
  if (current.name === name) return current.binding;
@@ -390,12 +385,13 @@ export const bindValue = (scope: Scope | undefined, name: string, value: Value):
390
385
  parent: scope,
391
386
  });
392
387
 
393
- const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Value) => {
388
+ export const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Value) => {
394
389
  if (pattern.kind === "Name") return bindValue(scope, pattern.name, value);
395
390
  const elements = getSequenceElements(value);
396
391
  if (!elements || elements.length !== pattern.names.length) {
392
+ const range = pattern.ranges?.[0];
397
393
  throw new TlaEvaluationError(
398
- `Cannot bind <<${pattern.names.join(", ")}>> to ${formatValue(value)}, which is not a tuple of that length`,
394
+ `Argument mismatch in operator application.${range ? formatRange(range) : ""}`,
399
395
  );
400
396
  }
401
397
  return pattern.names.reduce<Scope | undefined>(
@@ -404,7 +400,6 @@ const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Val
404
400
  );
405
401
  };
406
402
 
407
- // Tool#evalAppl checks that it applies a function before it evaluates the argument.
408
403
  export const expectFunction = (value: Value, application: Expression) => {
409
404
  if (isFunctionValue(value)) return value;
410
405
  throw new TlaEvaluationError(
@@ -440,6 +435,42 @@ export const expectBoolean = (value: Value, description: string) => {
440
435
  return value;
441
436
  };
442
437
 
438
+ export const expectImplication = (value: Value, expression: Expression, side: "P" | "Q") => {
439
+ if (typeof value !== "boolean") {
440
+ throw new TlaEvaluationError(
441
+ `Attempted to evaluate an expression of form P => Q when ${side} was\n${getKindString(value)}.\n${describeRange(expression)}`,
442
+ );
443
+ }
444
+ return value;
445
+ };
446
+
447
+ export const negate = (value: Value, expression: Expression) => {
448
+ if (typeof value !== "boolean") {
449
+ throw new TlaEvaluationError(
450
+ `Attempted to apply the operator ~ to a non-boolean\n(${getKindString(value)})\n${describeRange(expression)}`,
451
+ );
452
+ }
453
+ return !value;
454
+ };
455
+
456
+ export const isEquivalent = (left: Value, right: Value, expression: Expression) => {
457
+ if (typeof left !== "boolean" || typeof right !== "boolean") {
458
+ throw new TlaEvaluationError(
459
+ `Attempted to evaluate an expression of form P <=> Q when P or Q was not a boolean.\n${describeRange(expression)}`,
460
+ );
461
+ }
462
+ return left === right;
463
+ };
464
+
465
+ export const expectBooleanBody = (value: Value, expression: Expression) => {
466
+ if (typeof value !== "boolean") {
467
+ throw new TlaEvaluationError(
468
+ `TLC expected a boolean value, but did not find one. ${describeNode(expression)}`,
469
+ );
470
+ }
471
+ return value;
472
+ };
473
+
443
474
  export const getDefinition = (name: string, environment: Environment) =>
444
475
  environment.definitions.get(environment.substitutions.get(name) ?? name);
445
476
 
@@ -459,12 +490,9 @@ const getBoundExplanation = (set: Value, text: string) => {
459
490
  return undefined;
460
491
  };
461
492
 
462
- // TLC enumerates every set except the ones it implements in Java, so any other set fails as its own
463
- // class does.
464
493
  const checkEnumerable = (set: Value, expression: Expression, version: TlcVersion) => {
465
494
  if (!isSetValue(set) || isOverriddenSet(set)) {
466
495
  const text = formatValue(set);
467
- // TLC 1.7.4 doesn't explain why it can't enumerate a set.
468
496
  const explanation = version === "1.7.4" ? undefined : getBoundExplanation(set, text);
469
497
  throw new TlaEvaluationError(
470
498
  explanation === undefined
@@ -480,16 +508,12 @@ const getEnumeratedElements = (set: Value, expression: Expression, version: TlcV
480
508
  return getLazySubsets(set) ?? getNormalizedSetElements(set);
481
509
  };
482
510
 
483
- // The elements Tool.contexts binds to the bound of a quantifier or a set map. TLC 1.7.4 streams a
484
- // lazy set's elements, where later versions normalize the set first.
485
511
  export const getContextElements = (set: Value, expression: Expression, version: TlcVersion) => {
486
512
  if (version !== "1.7.4") return getEnumeratedElements(set, expression, version);
487
513
  checkEnumerable(set, expression, version);
488
514
  return getLazySubsets(set) ?? getStreamedElements(set);
489
515
  };
490
516
 
491
- // Like TLC, a quantifier keeps an interval as an interval, so that it can stop at the first witness
492
- // in a large interval such as 1..2000000000 without listing it.
493
517
  const getKeptInterval = (set: Value) => {
494
518
  if (typeof set !== "object" || set.kind !== "Interval") return undefined;
495
519
  getCardinality(set);
@@ -499,7 +523,6 @@ const getKeptInterval = (set: Value) => {
499
523
  export const getQuantifierElements = (set: Value, expression: Expression, version: TlcVersion) =>
500
524
  getKeptInterval(set) ?? getContextElements(set, expression, version);
501
525
 
502
- // CHOOSE and a function constructor visit the elements of the normalized set.
503
526
  const getNormalizedElements = (set: Value, expression: Expression, version: TlcVersion) =>
504
527
  getKeptInterval(set) ?? getEnumeratedElements(set, expression, version);
505
528
 
@@ -514,16 +537,22 @@ const someElement = (
514
537
  return false;
515
538
  };
516
539
 
540
+ export const mapBoundSets = <Result>(
541
+ bounds: Bound[],
542
+ map: (set: Expression, index: number) => Result,
543
+ ) =>
544
+ bounds.reduce<Result[]>((results, bound, index) => {
545
+ results.push(
546
+ index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set, index),
547
+ );
548
+ return results;
549
+ }, []);
550
+
517
551
  export const getBoundElements = (bounds: Bound[], context: Context) =>
518
- bounds.map((bound) =>
519
- getQuantifierElements(
520
- evaluate(bound.set, context),
521
- bound.set,
522
- context.environment.runtime.version,
523
- ),
552
+ mapBoundSets(bounds, (set) =>
553
+ getQuantifierElements(evaluate(set, context), set, context.environment.runtime.version),
524
554
  );
525
555
 
526
- // Visits each binding of the bounds to the elements of their sets, until visit returns true.
527
556
  export const forEachBoundElement = (
528
557
  bounds: Bound[],
529
558
  sets: ReturnType<typeof getBoundElements>,
@@ -545,8 +574,33 @@ export const forEachBinding = (
545
574
  visit: (scope: Scope | undefined) => boolean,
546
575
  ) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
547
576
 
577
+ const forEachChargedBinding = (
578
+ bounds: Bound[],
579
+ context: Context,
580
+ coverage: Coverage,
581
+ visit: (scope: Scope | undefined) => boolean,
582
+ ) => {
583
+ const bounded = mapBoundSets(bounds, (set) => {
584
+ const value = evaluate(set, context);
585
+ return {
586
+ value,
587
+ elements: getQuantifierElements(value, set, context.environment.runtime.version),
588
+ };
589
+ });
590
+ const sets = bounded.map((item) => item.elements);
591
+ const charge = chargeContexts(
592
+ coverage,
593
+ bounded.map((item) => item.value),
594
+ sets,
595
+ );
596
+ return forEachBoundElement(bounds, sets, context.scope, (scope) => {
597
+ charge();
598
+ return visit(scope);
599
+ });
600
+ };
601
+
548
602
  const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
549
- const sets = bounds.map((bound) => evaluate(bound.set, context));
603
+ const sets = mapBoundSets(bounds, (set) => evaluate(set, context));
550
604
  return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
551
605
  };
552
606
 
@@ -559,8 +613,6 @@ const bindArgument = (bounds: Bound[], scope: Scope | undefined, argument: Value
559
613
  );
560
614
  };
561
615
 
562
- // The parameters, body and scope of each function a constructor or a definition keeps lazy, whose
563
- // body TLC's getInitStates and getNextStates walk for an argument, as they do a FcnLambdaValue's.
564
616
  interface LazyFunction {
565
617
  value: LazyFunctionValue;
566
618
  bounds: Bound[];
@@ -568,8 +620,7 @@ interface LazyFunction {
568
620
  scope: Scope | undefined;
569
621
  }
570
622
 
571
- // The function keeps its parameters, body and scope itself, since a WeakMap entry for each
572
- // short-lived function makes every garbage collection slower.
623
+ // Kept on the value itself, since a WeakMap entry per short-lived function slows every GC.
573
624
  interface KeptLazyFunctionValue extends LazyFunctionValue {
574
625
  lambda: LazyFunction;
575
626
  }
@@ -582,8 +633,6 @@ const keepLambda = (lambda: LazyFunction) => Object.assign(lambda.value, { lambd
582
633
  export const getLazyFunction = (value: Value) =>
583
634
  isKeptLazyFunction(value) ? value.lambda : undefined;
584
635
 
585
- // Tool.getFcnContext: the scope of a lazy function's body for the arguments of an application. It
586
- // ignores arguments beyond the parameters.
587
636
  export const bindLazyArguments = (
588
637
  lambda: LazyFunction,
589
638
  expression: Expression & { kind: "FunctionApplication" },
@@ -608,12 +657,18 @@ export const bindLazyArguments = (
608
657
  typeof value.domain === "object" && value.domain.kind === "ProductSet"
609
658
  ? value.domain.factors
610
659
  : [];
611
- if (elements === undefined || elements.length < bounds.length) {
660
+ if (elements === undefined) {
612
661
  throw new TlaEvaluationError(
613
662
  `Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
614
663
  );
615
664
  }
665
+ // Deviation from TLC: Tool#getFcnContext indexes past an argument tuple shorter than the bounds and ignores a longer one.
666
+ const createListError = () =>
667
+ new TlaEvaluationError(
668
+ `In applying the function\n${prettyPrint(formatValue(value))},\nthe argument list is:\n${prettyPrint(formatValue(argument))}\nwhich does not match its formal parameter.\n`,
669
+ );
616
670
  bounds.forEach((bound, index) => {
671
+ if (index >= elements.length) throw createListError();
617
672
  const element = elements[index];
618
673
  const ordinal = `argument number ${index + 1}`;
619
674
  if (!isElementOf(element, domains[index])) {
@@ -634,11 +689,10 @@ export const bindLazyArguments = (
634
689
  );
635
690
  }
636
691
  });
637
- return bindArgument(bounds, lambda.scope, createTuple(elements.slice(0, bounds.length)));
692
+ if (elements.length > bounds.length) throw createListError();
693
+ return bindArgument(bounds, lambda.scope, argument);
638
694
  };
639
695
 
640
- // TLC prints a function it can't enumerate as its parameters and the location of its body. It
641
- // prints only the first name of a group such as `m, n \in S`.
642
696
  interface LazyFunctionTemplate {
643
697
  parameters: { index: number; name: string }[];
644
698
  body: string;
@@ -661,7 +715,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
661
715
  },
662
716
  ],
663
717
  ),
664
- body: formatRange(range),
718
+ body: describeNode(body),
665
719
  };
666
720
  };
667
721
 
@@ -684,22 +738,29 @@ const getLazyFunctionSource = (
684
738
  };
685
739
  };
686
740
 
687
- // TLC's FcnLambdaValue evaluates its body at each application.
688
741
  const createLazyFunction = (
689
742
  domain: Value,
690
743
  compute: (argument: Value, self: LazyFunctionValue) => Value,
691
744
  source: LazyFunctionSource | undefined,
745
+ boundTupleLengths: (number | undefined)[] | undefined,
692
746
  ) => {
693
747
  const self: LazyFunctionValue = {
694
748
  kind: "LazyFunction",
695
749
  domain,
696
750
  source,
751
+ boundTupleLengths,
697
752
  apply: (argument) => compute(argument, self),
698
753
  };
699
754
  return self;
700
755
  };
701
756
 
702
- // The function constructor of a definition, which SANY locates at the whole definition.
757
+ const getBoundTupleLengths = (bounds: Bound[]) =>
758
+ bounds.length === 1
759
+ ? undefined
760
+ : bounds.map((bound) =>
761
+ bound.pattern.kind === "Tuple" ? bound.pattern.names.length : undefined,
762
+ );
763
+
703
764
  const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
704
765
  kind: "FunctionConstruction",
705
766
  bounds: definition.bounds,
@@ -707,7 +768,10 @@ const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
707
768
  location: definition.location,
708
769
  });
709
770
 
710
- const createRecursiveFunction = (definition: FunctionDefinition, context: Context) => {
771
+ const createRecursiveFunction = (
772
+ definition: FunctionDefinition,
773
+ context: Context,
774
+ ): RebindableLazyFunction => {
711
775
  const domain = getBoundsDomain(definition.bounds, context);
712
776
  const functionValue = createLazyFunction(
713
777
  domain,
@@ -724,6 +788,7 @@ const createRecursiveFunction = (definition: FunctionDefinition, context: Contex
724
788
  definition.bounds,
725
789
  domain,
726
790
  ),
791
+ getBoundTupleLengths(definition.bounds),
727
792
  );
728
793
  keepLambda({
729
794
  value: functionValue,
@@ -731,11 +796,16 @@ const createRecursiveFunction = (definition: FunctionDefinition, context: Contex
731
796
  body: definition.body,
732
797
  scope: bindValue(undefined, definition.name, functionValue),
733
798
  });
734
- return definition.bounds.length === 1 ? markLambdaFunction(functionValue) : functionValue;
799
+ const rebindable: RebindableLazyFunction = Object.assign(functionValue, {
800
+ rebind: (tracing: Environment) => {
801
+ const rebound = createRecursiveFunction(definition, { ...context, environment: tracing });
802
+ rebound.enumerated = functionValue.enumerated;
803
+ return rebound;
804
+ },
805
+ });
806
+ return definition.bounds.length === 1 ? markLambdaFunction(rebindable) : rebindable;
735
807
  };
736
808
 
737
- // TLC computes a constant definition when it starts, without keeping a function it constructs
738
- // lazy, so a function over an interval or an enumerated set is a FcnRcdValue.
739
809
  const toStartupValue = (definition: Definition, value: Value): Value => {
740
810
  if (typeof value !== "object" || getFunctionClass(value) !== "lambda") return value;
741
811
  if (
@@ -750,14 +820,11 @@ const toStartupValue = (definition: Definition, value: Value): Value => {
750
820
  const finite = toFiniteFunction(value);
751
821
  return createSortedFunction(finite.domain, finite.range);
752
822
  } catch (error) {
753
- // TLC leaves a definition it fails to compute to evaluate where the spec uses it.
754
823
  if (error instanceof TlaEvaluationError) return value;
755
824
  throw error;
756
825
  }
757
826
  };
758
827
 
759
- // The code of a definition's body, evaluated as a whole. TLC evaluates a function definition that
760
- // isn't recursive as it does a function constructor.
761
828
  const compileDefinitionBody = (definition: Definition, environment: Environment): Evaluator => {
762
829
  if (definition.kind === "Operator" && definition.params.length > 0) {
763
830
  return () => {
@@ -772,59 +839,100 @@ const compileDefinitionBody = (definition: Definition, environment: Environment)
772
839
  return getEntryEvaluator(getDefinitionSource(definition), environment);
773
840
  };
774
841
 
775
- // The code that evaluates a reference to a definition: the value TLC computed at startup when it
776
- // has one, and the body at the top level otherwise.
842
+ const CALLER_SCOPE: Scope = {
843
+ name: "",
844
+ binding: { kind: "Value", value: false },
845
+ parent: undefined,
846
+ };
847
+
777
848
  const getDefinitionEvaluator = (definition: Definition, environment: Environment): Evaluator => {
778
849
  const compiled = environment.definitionEvaluators.get(definition);
779
850
  if (compiled) return compiled;
780
851
  const body = compileDefinitionBody(definition, environment);
781
- const id = environment.facts.ids.get(definition);
852
+ const definitionId = environment.facts.ids.get(definition);
782
853
  const startupValues = environment.startupValues;
783
- const evaluator: Evaluator =
784
- id === undefined
854
+ const isInCallerContext =
855
+ definition.kind === "Operator" &&
856
+ definition.params.length === 0 &&
857
+ isTlcEvalReached(definition.body, environment);
858
+ const evaluator: Evaluator = isInCallerContext
859
+ ? (context) =>
860
+ (definitionId === undefined ? undefined : startupValues[definitionId]) ??
861
+ body(withScope(context, isTlcContextEmpty(context.scope) ? undefined : CALLER_SCOPE))
862
+ : definitionId === undefined
785
863
  ? (context) => body(withScope(context, undefined))
786
- : (context) => startupValues[id] ?? body(withScope(context, undefined));
864
+ : (context) => startupValues[definitionId] ?? body(withScope(context, undefined));
787
865
  environment.definitionEvaluators.set(definition, evaluator);
788
866
  return evaluator;
789
867
  };
790
868
 
791
869
  export const getStartupValue = (definition: Definition, environment: Environment) => {
792
- const id = environment.facts.ids.get(definition);
793
- return id === undefined ? undefined : environment.startupValues[id];
870
+ const definitionId = environment.facts.ids.get(definition);
871
+ return definitionId === undefined ? undefined : environment.startupValues[definitionId];
794
872
  };
795
873
 
796
- // TLC computes each constant definition the configuration doesn't replace when it starts, and
797
- // leaves one it fails to compute to evaluate where the spec uses it.
798
874
  export const evaluateStartupDefinitions = (definitions: Definition[], environment: Environment) =>
799
875
  definitions.forEach((definition) => {
800
876
  if (definition.kind === "Operator" && definition.params.length > 0) return;
801
877
  const name = definition.name;
802
878
  if (environment.constants.has(name) || environment.substitutions.has(name)) return;
803
- if (!isConstantLevel(definition, environment)) return;
804
- const id = environment.facts.ids.get(definition);
805
- if (id === undefined || environment.startupValues[id] !== undefined) return;
879
+ if (!isEvaluatedAtStartup(definition, environment)) return;
880
+ const definitionId = environment.facts.ids.get(definition);
881
+ if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
806
882
  const context = { environment, scope: undefined, state: undefined, next: undefined };
807
883
  try {
808
884
  const value = environment.runtime.evaluateAtStartup(() =>
809
885
  toStartupValue(definition, compileDefinitionBody(definition, environment)(context)),
810
886
  );
811
887
  markNormalized(value);
812
- environment.startupValues[id] = value;
888
+ environment.startupValues[definitionId] = value;
813
889
  } catch (error) {
814
890
  // TLC swallows whatever the definition throws, a stack overflow included.
815
891
  if (!(error instanceof TlaEvaluationError) && !isStackOverflow(error)) throw error;
816
892
  }
817
893
  });
818
894
 
895
+ const isStateWithin = (state: State | undefined, cached: State | undefined) => {
896
+ if (cached === undefined || state === cached) return true;
897
+ try {
898
+ return cached.every(
899
+ (value, index) =>
900
+ value === undefined || (state?.[index] !== undefined && valuesEqual(state[index], value)),
901
+ );
902
+ } catch (error) {
903
+ if (error instanceof TlaEvaluationError) return false;
904
+ throw error;
905
+ }
906
+ };
907
+
819
908
  const forceThunk = (thunk: Thunk, context: Context) => {
820
- const isSameState = thunk.state === context.state && thunk.next === context.next;
821
- if (isSameState && thunk.cache !== undefined) return thunk.cache;
822
- const value = evaluate(thunk.expression, withScope(context, thunk.scope));
823
- if (isSameState && (!thunk.isStreamed || isSettledValue(value))) thunk.cache = value;
909
+ const cache = thunk.cache;
910
+ const isCached =
911
+ cache !== undefined &&
912
+ isStateWithin(context.state, thunk.state) &&
913
+ isStateWithin(context.next, thunk.next);
914
+ if (isCached) return cache;
915
+ const coverage = context.environment.coverage;
916
+ const node = coverage?.current === -1 ? undefined : coverage?.values.get(thunk);
917
+ const value =
918
+ coverage && node !== undefined
919
+ ? runAtCoverageNode(coverage, node, () =>
920
+ evaluate(thunk.expression, withScope(context, thunk.scope)),
921
+ )
922
+ : evaluate(thunk.expression, withScope(context, thunk.scope));
923
+ if (!thunk.isStreamed || isSettledValue(value)) {
924
+ thunk.cache = value;
925
+ thunk.state = context.state;
926
+ thunk.next = context.next;
927
+ }
928
+ if (thunk.cache !== undefined && thunk.state === undefined && thunk.next === undefined) {
929
+ thunk.scope = undefined;
930
+ thunk.isReleased = true;
931
+ }
824
932
  return value;
825
933
  };
826
934
 
827
- const getDefinitionClosure = (definition: Definition & { kind: "Operator" }): Closure => ({
935
+ export const getDefinitionClosure = (definition: Definition & { kind: "Operator" }): Closure => ({
828
936
  kind: "Closure",
829
937
  name: definition.name,
830
938
  params: definition.params,
@@ -888,6 +996,12 @@ const evaluateOperatorArgument = (expression: Expression, context: Context): Ope
888
996
  };
889
997
 
890
998
  const callOperatorWithValues = (operator: Operator, args: Value[], context: Context): Value => {
999
+ if (operator.kind === "Builtin" && operator.isLazy) {
1000
+ return operator.evaluate(
1001
+ args.map((value) => ({ kind: "Operator", name: "argument", arity: 0, call: () => value })),
1002
+ context,
1003
+ );
1004
+ }
891
1005
  if (operator.kind === "Builtin") return operator.evaluate(args, context);
892
1006
  if (operator.kind === "Operator") return operator.call(args);
893
1007
  const scope = operator.params.reduce<Scope | undefined>(
@@ -905,11 +1019,6 @@ const toOperatorValue = (operator: Operator, context: Context): OperatorValue =>
905
1019
  name: operator.name,
906
1020
  arity: getArity(operator),
907
1021
  call: (args) => callOperatorWithValues(operator, args, context),
908
- literalBody:
909
- operator.kind === "Closure" &&
910
- (operator.body.kind === "Number" || operator.body.kind === "String")
911
- ? operator.body.value
912
- : undefined,
913
1022
  };
914
1023
 
915
1024
  const isOperatorArgument = (expression: Expression, context: Context) => {
@@ -919,6 +1028,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
919
1028
  return operator !== undefined && getArity(operator) > 0;
920
1029
  };
921
1030
 
1031
+ // Deviation from TLC: SymbolNodeValueLookupProvider#lookup takes an operator whose body is a literal for that literal, so a Java override rejects it as an argument.
922
1032
  const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
923
1033
  args.map((arg) =>
924
1034
  isOperatorArgument(arg, context)
@@ -961,9 +1071,17 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
961
1071
  const isLiteral =
962
1072
  argument.kind === "String" || (argument.kind === "Number" && isTlcInteger(argument.value));
963
1073
  if (isLiteral) {
964
- const binding: Binding = { kind: "Value", value: argument.value };
1074
+ const binding: Binding = { kind: "Value", value: argument.value, argument };
965
1075
  return () => binding;
966
1076
  }
1077
+ const coverage = environment.coverage;
1078
+ if (coverage) {
1079
+ return (context) => {
1080
+ const thunk = createThunk(argument, context);
1081
+ if (coverage.current !== -1) coverage.values.set(thunk, coverage.current);
1082
+ return thunk;
1083
+ };
1084
+ }
967
1085
  if (argument.kind === "Identifier") {
968
1086
  const global = isLocallyResolved(argument)
969
1087
  ? undefined
@@ -972,7 +1090,7 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
972
1090
  const binding: Binding = { kind: "Value", value: global.value };
973
1091
  return () => binding;
974
1092
  }
975
- if (global === undefined) {
1093
+ if (global === undefined && !environment.callStack) {
976
1094
  return (context) => {
977
1095
  const binding = lookupScope(context.scope, argument.name);
978
1096
  return binding?.kind === "Value" || binding?.kind === "Thunk"
@@ -1020,65 +1138,90 @@ const callOperator = (
1020
1138
  return operator.evaluate(evaluateBuiltinArguments(args, context), context);
1021
1139
  };
1022
1140
 
1023
- // The LET definitions that a reference evaluates again, and those that cache only a settled value.
1024
1141
  interface ReevaluatedDefinitions {
1025
1142
  impure: ReadonlySet<Definition>;
1026
1143
  streamed: ReadonlySet<Definition>;
1027
1144
  }
1028
1145
 
1146
+ const letFunctionConstructions = new WeakMap<FunctionDefinition, Expression>();
1147
+
1148
+ const getLetFunctionConstruction = (definition: FunctionDefinition): Expression => {
1149
+ const known = letFunctionConstructions.get(definition);
1150
+ if (known) return known;
1151
+ const construction: Expression = {
1152
+ kind: "FunctionConstruction",
1153
+ bounds: definition.bounds,
1154
+ body: definition.body,
1155
+ location: definition.location,
1156
+ isRecursive: true,
1157
+ };
1158
+ letFunctionConstructions.set(definition, construction);
1159
+ return construction;
1160
+ };
1161
+
1029
1162
  export const bindDefinitions = (
1030
1163
  definitions: Definition[],
1031
1164
  context: Context,
1032
1165
  reevaluated?: ReevaluatedDefinitions,
1033
- ): Scope | undefined =>
1034
- definitions.reduce<Scope | undefined>((scope, definition) => {
1035
- const node: Scope = {
1036
- name: definition.name,
1037
- binding: { kind: "Value", value: false },
1038
- parent: scope,
1039
- };
1040
- if (definition.kind === "Function") {
1041
- node.binding = {
1042
- kind: "Thunk",
1043
- expression: {
1044
- kind: "FunctionConstruction",
1045
- bounds: definition.bounds,
1046
- body: definition.body,
1047
- location: definition.location,
1048
- isRecursive: true,
1049
- },
1050
- scope: node,
1051
- state: context.state,
1052
- next: context.next,
1053
- cache: undefined,
1054
- isStreamed: false,
1055
- };
1056
- return node;
1057
- }
1058
- if (definition.params.length > 0 || reevaluated?.impure.has(definition)) {
1059
- node.binding = {
1060
- kind: "Operator",
1061
- operator: {
1062
- kind: "Closure",
1063
- name: definition.name,
1064
- params: definition.params,
1065
- body: definition.body,
1066
- scope: node,
1067
- },
1068
- };
1069
- return node;
1070
- }
1071
- node.binding = {
1072
- kind: "Thunk",
1073
- expression: definition.body,
1074
- scope: node,
1075
- state: context.state,
1076
- next: context.next,
1077
- cache: undefined,
1078
- isStreamed: reevaluated?.streamed.has(definition) ?? false,
1079
- };
1166
+ ): Scope | undefined => {
1167
+ const nodes = definitions.map((definition): Scope => ({
1168
+ name: definition.name,
1169
+ binding: { kind: "Value", value: false },
1170
+ parent: undefined,
1171
+ }));
1172
+ const scope = nodes.reduce<Scope | undefined>((parent, node) => {
1173
+ node.parent = parent;
1080
1174
  return node;
1081
1175
  }, context.scope);
1176
+ let isRecursiveAtOrAfter = false;
1177
+ for (let index = definitions.length - 1; index >= 0; index--) {
1178
+ const definition = definitions[index];
1179
+ isRecursiveAtOrAfter ||= definition.isRecursive;
1180
+ // TLC's LET evaluates an operator without parameters in the context before it, which TLCEval#tlcEval tells from an empty one.
1181
+ const ownScope =
1182
+ definition.kind === "Operator" && definition.params.length === 0 && !isRecursiveAtOrAfter
1183
+ ? nodes[index].parent
1184
+ : scope;
1185
+ nodes[index].binding =
1186
+ definition.kind === "Function"
1187
+ ? {
1188
+ kind: "Thunk",
1189
+ expression: getLetFunctionConstruction(definition),
1190
+ scope,
1191
+ state: context.state,
1192
+ next: context.next,
1193
+ cache: undefined,
1194
+ isStreamed: false,
1195
+ }
1196
+ : definition.params.length > 0 || reevaluated?.impure.has(definition)
1197
+ ? {
1198
+ kind: "Operator",
1199
+ operator: {
1200
+ kind: "Closure",
1201
+ name: definition.name,
1202
+ params: definition.params,
1203
+ body: definition.body,
1204
+ scope: ownScope,
1205
+ },
1206
+ }
1207
+ : {
1208
+ kind: "Thunk",
1209
+ expression: definition.body,
1210
+ scope: ownScope,
1211
+ state: context.state,
1212
+ next: context.next,
1213
+ cache: undefined,
1214
+ isStreamed: reevaluated?.streamed.has(definition) ?? false,
1215
+ };
1216
+ }
1217
+ const coverage = context.environment.coverage;
1218
+ if (coverage && coverage.current !== -1) {
1219
+ nodes.forEach((node) => {
1220
+ if (node.binding.kind === "Thunk") coverage.values.set(node.binding, coverage.current);
1221
+ });
1222
+ }
1223
+ return scope;
1224
+ };
1082
1225
 
1083
1226
  const evaluateLocalIdentifier = (name: string, expression: Expression, context: Context): Value => {
1084
1227
  const binding = lookupScope(context.scope, name);
@@ -1100,19 +1243,22 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
1100
1243
  if (global?.kind === "Definition") {
1101
1244
  return getDefinitionEvaluator(global.definition, context.environment)(context);
1102
1245
  }
1103
- const builtin = context.environment.builtins.get(name);
1246
+ const builtin = context.environment.builtins.get(
1247
+ context.environment.substitutions.get(name) ?? name,
1248
+ );
1104
1249
  if (builtin?.arity === 0) return builtin.evaluate([], context);
1105
- throw new TlaEvaluationError(`Unknown identifier ${name} at ${describeLocation(expression)}`);
1250
+ throw new TlaEvaluationError(
1251
+ `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
1252
+ );
1106
1253
  };
1107
1254
 
1108
- // TLC's next-state generator does not bind LET definitions to values, so each reference to one
1109
- // evaluates it again: one that calls an impure builtin repeats its effects, and a set one builds
1110
- // with UNION or \cup starts out uncached.
1111
1255
  export const getReevaluatedDefinitions = (
1112
1256
  definitions: Definition[],
1113
1257
  environment: Environment,
1114
1258
  ): ReevaluatedDefinitions => ({
1115
- impure: new Set(definitions.filter((definition) => isImpureDefinition(definition, environment))),
1259
+ impure: new Set(
1260
+ definitions.filter((definition) => isImpureDefinition(definition, environment, "varying")),
1261
+ ),
1116
1262
  streamed: new Set(
1117
1263
  definitions.filter((definition) => isImpureDefinition(definition, environment, "streamed")),
1118
1264
  ),
@@ -1123,23 +1269,39 @@ export const isImpure = (environment: Environment) =>
1123
1269
  isImpureDefinition(definition, environment),
1124
1270
  );
1125
1271
 
1126
- // Whether evaluating a definition again can show, such as by printing twice.
1127
1272
  export const hasRepeatedEffects = (environment: Environment) =>
1128
1273
  [...environment.facts.ids.keys()].some((definition) =>
1129
1274
  isImpureDefinition(definition, environment, "repeated"),
1130
1275
  );
1131
1276
 
1132
- // A set filter TLC evaluates lazily, with how to rebuild it so that its predicate runs in another
1133
- // environment.
1134
1277
  interface RebindableFilteredSet extends FilteredSetValue {
1135
1278
  rebind: (environment: Environment) => Value;
1136
1279
  }
1137
1280
 
1138
- const isRebindableFilteredSet = (value: Value): value is RebindableFilteredSet =>
1139
- typeof value === "object" && value.kind === "FilteredSet" && "rebind" in value;
1281
+ interface RebindableLazyFunction extends LazyFunctionValue {
1282
+ rebind: (environment: Environment) => Value;
1283
+ }
1284
+
1285
+ const isRebindable = (value: Value): value is RebindableFilteredSet | RebindableLazyFunction =>
1286
+ typeof value === "object" &&
1287
+ (value.kind === "FilteredSet" || value.kind === "LazyFunction") &&
1288
+ "rebind" in value;
1289
+
1290
+ export const toNextContext = (context: Context): Context => ({
1291
+ environment: context.environment,
1292
+ scope: context.scope,
1293
+ state: context.next,
1294
+ next: undefined,
1295
+ isKeepLazy: context.isKeepLazy,
1296
+ });
1297
+
1298
+ const compileUnchanged =
1299
+ (evaluator: Evaluator): Evaluator =>
1300
+ (context) => {
1301
+ const current = evaluator(context);
1302
+ return valuesEqual(current, evaluator(toNextContext(context)));
1303
+ };
1140
1304
 
1141
- // TLC's CallStackTool rebinds the lazy values its evaluations return, so their later evaluation
1142
- // records its call stack too.
1143
1305
  const traceEvaluator =
1144
1306
  (
1145
1307
  expression: Expression,
@@ -1157,13 +1319,17 @@ const traceEvaluator =
1157
1319
  setTrace.callStack = callStack;
1158
1320
  try {
1159
1321
  const computed = evaluator(context);
1160
- const value = isRebindableFilteredSet(computed) ? computed.rebind(environment) : computed;
1322
+ const value = isRebindable(computed) ? computed.rebind(environment) : computed;
1161
1323
  callStack.values.set(expression, value);
1162
1324
  if (typeof value === "object" && value.kind !== "FilteredSet" && isSourced(expression)) {
1163
1325
  callStack.sources.set(value, expression);
1164
1326
  }
1165
1327
  return value;
1166
1328
  } catch (error) {
1329
+ if (error instanceof TlaSetBoundError && !callStack.isFrozen) {
1330
+ callStack.expressions.length = 0;
1331
+ callStack.isFrozen = true;
1332
+ }
1167
1333
  const failed = error instanceof Error ? callStack.failures.get(error) : undefined;
1168
1334
  if (error instanceof Error) callStack.failures.set(error, expression);
1169
1335
  const receiver = getReceiver(expression, callStack.values);
@@ -1191,20 +1357,15 @@ const traceEvaluator =
1191
1357
  }
1192
1358
  };
1193
1359
 
1194
- // A method of a value with a source raises a FingerprintException, which each value with a source
1195
- // whose method called it heads in turn. CallStack#freeze adds their sources to the stack, outermost
1196
- // first. The values are those whose methods failed, outermost first.
1197
1360
  export const freezeCallStack = (
1198
1361
  callStack: CallStack,
1199
1362
  values: (Value | undefined)[],
1200
1363
  error: unknown,
1201
1364
  ) => {
1202
- // A set that streams its elements enumerates itself too, so it can appear twice.
1203
1365
  const sources = [...new Set(values)].flatMap((item) => {
1204
1366
  const source = typeof item === "object" ? callStack.sources.get(item) : undefined;
1205
1367
  return source ? [source] : [];
1206
1368
  });
1207
- // A value with a source raises a FingerprintException even when the stack is frozen already.
1208
1369
  if (sources.length > 0 && error instanceof TlaEvaluationError) {
1209
1370
  if (!callStack.isFrozen) callStack.expressions.push(...sources);
1210
1371
  const inner = callStack.fingerprint;
@@ -1216,8 +1377,6 @@ export const freezeCallStack = (
1216
1377
  callStack.isFrozen = true;
1217
1378
  };
1218
1379
 
1219
- // A FingerprintException that a method of a value with a source raises, or that passes through one,
1220
- // takes the value's source as its new head.
1221
1380
  const headFingerprint = (callStack: CallStack, source: Expression, error: unknown) => {
1222
1381
  if (!(error instanceof TlaEvaluationError)) return;
1223
1382
  if (!callStack.isFrozen) callStack.expressions.push(source);
@@ -1229,8 +1388,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
1229
1388
  };
1230
1389
  };
1231
1390
 
1232
- // A copy of the environment that records the call stack of each evaluation, with evaluators of its
1233
- // own since the environment's evaluators record nothing.
1234
1391
  export const createTracingEnvironment = (environment: Environment): Environment => ({
1235
1392
  ...environment,
1236
1393
  evaluators: new WeakMap(),
@@ -1245,20 +1402,107 @@ export const createTracingEnvironment = (environment: Environment): Environment
1245
1402
  },
1246
1403
  });
1247
1404
 
1405
+ // TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
1406
+ const compileTracedJunction = (
1407
+ expression: Expression & { kind: "And" | "Or" },
1408
+ operands: Evaluator[],
1409
+ callStack: CallStack | undefined,
1410
+ ): Evaluator | undefined => {
1411
+ const range = expression.location.range;
1412
+ const prefixEnds = expression.prefixEnds;
1413
+ if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
1414
+ return undefined;
1415
+ }
1416
+ const prefixes = prefixEnds
1417
+ .slice(0, operands.length - 2)
1418
+ .map((end) => ({
1419
+ ...expression,
1420
+ location: { ...expression.location, range: { ...range, end } },
1421
+ }))
1422
+ .reverse();
1423
+ const isAnd = expression.kind === "And";
1424
+ return (context) => {
1425
+ callStack.expressions.push(...prefixes);
1426
+ for (let index = 0; index < operands.length; index++) {
1427
+ if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
1428
+ const value = operands[index](context);
1429
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
1430
+ if (value !== isAnd) {
1431
+ if (!callStack.isFrozen)
1432
+ callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
1433
+ return value;
1434
+ }
1435
+ }
1436
+ return isAnd;
1437
+ };
1438
+ };
1439
+
1440
+ const traceFrames =
1441
+ (
1442
+ expression: Expression,
1443
+ frames: Expression[],
1444
+ evaluator: Evaluator,
1445
+ callStack: CallStack,
1446
+ ): Evaluator =>
1447
+ (context) => {
1448
+ if (callStack.expressions.at(-1) === expression) return evaluator(context);
1449
+ callStack.expressions.push(...frames);
1450
+ try {
1451
+ return evaluator(context);
1452
+ } finally {
1453
+ if (!callStack.isFrozen) callStack.expressions.length -= frames.length;
1454
+ }
1455
+ };
1456
+
1457
+ const countEvaluator =
1458
+ (expression: Expression, evaluator: Evaluator, coverage: Coverage): Evaluator =>
1459
+ (context) => {
1460
+ const outer = coverage.current;
1461
+ if (outer === -1 || !coverage.covered.has(expression)) return evaluator(context);
1462
+ const node = getCoverageNode(coverage, outer, expression);
1463
+ countCoverage(coverage, node);
1464
+ coverage.current = node;
1465
+ try {
1466
+ const value = evaluator(context);
1467
+ const isTagged =
1468
+ expression.kind === "SetEnumeration" ||
1469
+ ((expression.kind === "SetFilter" || expression.kind === "SetMap") &&
1470
+ isReducibleSet(value)) ||
1471
+ (expression.kind === "SetFilter" &&
1472
+ typeof value === "object" &&
1473
+ value.kind === "FilteredSet") ||
1474
+ ((expression.kind === "FunctionSet" || expression.kind === "RecordSet") &&
1475
+ typeof value === "object" &&
1476
+ value.kind === expression.kind) ||
1477
+ (expression.kind === "Apply" &&
1478
+ expression.operator === "SUBSET" &&
1479
+ typeof value === "object" &&
1480
+ value.kind === "Subset");
1481
+ if (typeof value === "object" && isTagged) coverage.values.set(value, node);
1482
+ return value;
1483
+ } finally {
1484
+ coverage.current = outer;
1485
+ }
1486
+ };
1487
+
1248
1488
  export const getEvaluator = (expression: Expression, environment: Environment): Evaluator => {
1249
1489
  const cached = environment.evaluators.get(expression);
1250
1490
  if (cached) return cached;
1251
1491
  const compiled = compile(expression, environment);
1252
1492
  const callStack = environment.callStack;
1253
- const evaluator = callStack
1493
+ const frames = callStack && substitutionFrames.get(expression);
1494
+ const traced = callStack
1254
1495
  ? traceEvaluator(expression, compiled, environment, callStack)
1255
1496
  : compiled;
1497
+ const framed = callStack && frames ? traceFrames(expression, frames, traced, callStack) : traced;
1498
+ const coverage = environment.coverage;
1499
+ const evaluator = coverage ? countEvaluator(expression, framed, coverage) : framed;
1256
1500
  environment.evaluators.set(expression, evaluator);
1257
1501
  return evaluator;
1258
1502
  };
1259
1503
 
1260
1504
  export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
1261
- if (environment.callStack) return getEvaluator(expression, environment);
1505
+ if (environment.callStack || environment.coverage) return getEvaluator(expression, environment);
1262
1506
  const compiled = environment.entryEvaluators.get(expression);
1263
1507
  if (compiled) return compiled;
1264
1508
  const evaluator =
@@ -1289,12 +1533,9 @@ const compileIdentifier = (
1289
1533
  return () => value;
1290
1534
  }
1291
1535
  if (global?.kind === "Definition") {
1292
- // The body compiles when the reference is first evaluated, as a recursive definition's body
1293
- // refers back to it.
1294
1536
  const definition = global.definition;
1295
- const compiled = { reference: undefined as Evaluator | undefined };
1296
- return (context) =>
1297
- (compiled.reference ??= getDefinitionEvaluator(definition, environment))(context);
1537
+ let compiled: Evaluator | undefined;
1538
+ return (context) => (compiled ??= getDefinitionEvaluator(definition, environment))(context);
1298
1539
  }
1299
1540
  return (context) => evaluateLocalIdentifier(name, expression, context);
1300
1541
  };
@@ -1374,11 +1615,10 @@ const compileClosureCall = (
1374
1615
  environment: Environment,
1375
1616
  ): Evaluator => {
1376
1617
  const bindArguments = compileArgumentScope(closure, args, environment);
1377
- // The body compiles when the call is first evaluated, as a recursive operator's body calls it.
1378
- const compiled = { body: undefined as Evaluator | undefined };
1618
+ let body: Evaluator | undefined;
1379
1619
  return (context) => {
1380
- compiled.body ??= getEntryEvaluator(closure.body, environment);
1381
- return compiled.body({
1620
+ body ??= getEntryEvaluator(closure.body, environment);
1621
+ return body({
1382
1622
  environment,
1383
1623
  scope: bindArguments(context),
1384
1624
  state: context.state,
@@ -1388,6 +1628,26 @@ const compileClosureCall = (
1388
1628
  };
1389
1629
  };
1390
1630
 
1631
+ // TLC's LET conses only its arity-0 definitions onto the context that TLCEval#tlcEval caches under when it is empty.
1632
+ const isTlcContextEmpty = (scope: Scope | undefined) => {
1633
+ for (let node = scope; node !== undefined; node = node.parent) {
1634
+ const binding = node.binding;
1635
+ if (
1636
+ binding.kind !== "Operator" ||
1637
+ binding.operator.kind !== "Closure" ||
1638
+ binding.operator.params.length === 0
1639
+ ) {
1640
+ return false;
1641
+ }
1642
+ let letScope = binding.operator.scope;
1643
+ while (letScope !== undefined && letScope !== node) letScope = letScope.parent;
1644
+ if (letScope !== node) return false;
1645
+ }
1646
+ return true;
1647
+ };
1648
+
1649
+ const SET_OPERATORS = new Set(["\\cup", "\\cap", "\\"]);
1650
+
1391
1651
  const compileApply = (
1392
1652
  expression: Expression & { kind: "Apply" },
1393
1653
  environment: Environment,
@@ -1397,12 +1657,24 @@ const compileApply = (
1397
1657
  const left = getEvaluator(args[0], environment);
1398
1658
  const right = getEvaluator(args[1], environment);
1399
1659
  return (context) =>
1400
- !expectBoolean(left(context), "the left side of =>") ||
1401
- expectBoolean(right(context), "the right side of =>");
1660
+ !expectImplication(left(context), expression, "P") ||
1661
+ expectImplication(right(context), expression, "Q");
1662
+ }
1663
+ if (expression.operator === "~" && args.length === 1) {
1664
+ const operand = getEvaluator(args[0], environment);
1665
+ return (context) => negate(operand(context), expression);
1402
1666
  }
1403
- if (expression.operator === "~>") {
1667
+ if (expression.operator === "<=>") {
1668
+ const left = getEvaluator(args[0], environment);
1669
+ const right = getEvaluator(args[1], environment);
1670
+ return (context) => isEquivalent(left(context), right(context), expression);
1671
+ }
1672
+ if (expression.operator === "~>" || expression.operator === "-+->") {
1404
1673
  return () => {
1405
- throw new TlaEvaluationError("TLC cannot evaluate a temporal formula such as ~> in a state");
1674
+ throw createTemporalFormulaError(
1675
+ expression.operator === "~>" ? "a ~> b" : "a -+-> formula",
1676
+ expression,
1677
+ );
1406
1678
  };
1407
1679
  }
1408
1680
  const global = isLocallyResolved(expression)
@@ -1414,23 +1686,66 @@ const compileApply = (
1414
1686
  const domain = getDomainOperator(expression);
1415
1687
  return (context) => domain(operand(context));
1416
1688
  }
1417
- // TLC sorts the value of a constant TLCEval argument only where no context binds a name.
1418
1689
  if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
1419
- const operand = getEvaluator(args[0], environment);
1420
- if (contextualApplications.has(expression) || isNonconstant(args[0], environment)) {
1421
- return operand;
1422
- }
1423
- return (context) =>
1424
- context.scope === undefined ? global.evaluate([operand(context)]) : operand(context);
1690
+ // Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
1691
+ const isCached =
1692
+ !contextualApplications.has(expression) && !isNonconstant(args[0], environment);
1693
+ const tlcEvalValues = environment.tlcEvalValues;
1694
+ return (context) => {
1695
+ if (!isCached || !isTlcContextEmpty(context.scope)) {
1696
+ return global.evaluate(getLazyArguments(args, context), context);
1697
+ }
1698
+ const cached = tlcEvalValues.get(expression);
1699
+ if (cached !== undefined) return cached;
1700
+ const value = global.evaluate(getLazyArguments(args, context), undefined);
1701
+ tlcEvalValues.set(expression, value);
1702
+ return value;
1703
+ };
1425
1704
  }
1426
- if (global?.kind === "Builtin" && global.name === "\\subseteq" && args.length === 2) {
1705
+ if (
1706
+ global?.kind === "Builtin" &&
1707
+ global.name === "\\subseteq" &&
1708
+ global.evaluateBinary &&
1709
+ args.length === 2
1710
+ ) {
1427
1711
  const left = getEvaluator(args[0], environment);
1428
1712
  const right = getEvaluator(args[1], environment);
1429
- const subset = getSubsetOperator(expression, global);
1430
- return (context) => subset(left(context), right(context));
1713
+ const subset = getSubsetOperator(expression, global.evaluateBinary);
1714
+ const coverage = environment.coverage;
1715
+ if (!coverage) return (context) => subset(left(context), right(context));
1716
+ return (context) => {
1717
+ const leftValue = left(context);
1718
+ const rightValue = right(context);
1719
+ if (
1720
+ typeof leftValue !== "object" ||
1721
+ leftValue.kind !== "Set" ||
1722
+ !coverage.values.has(leftValue)
1723
+ ) {
1724
+ return subset(leftValue, rightValue);
1725
+ }
1726
+ const missing = leftValue.elements.findIndex((element) => !isElementOf(element, rightValue));
1727
+ costCoverage(coverage, leftValue, (missing === -1 ? leftValue.elements.length : missing) + 1);
1728
+ return missing === -1;
1729
+ };
1730
+ }
1731
+ const coverage = environment.coverage;
1732
+ const combine = global?.kind === "Builtin" ? global.evaluateBinary : undefined;
1733
+ if (coverage && combine && SET_OPERATORS.has(expression.operator) && args.length === 2) {
1734
+ const left = getEvaluator(args[0], environment);
1735
+ const right = getEvaluator(args[1], environment);
1736
+ return (context) => {
1737
+ const leftValue = left(context);
1738
+ const rightValue = right(context);
1739
+ return chargeSetOperation(
1740
+ coverage,
1741
+ expression.operator,
1742
+ leftValue,
1743
+ rightValue,
1744
+ combine(leftValue, rightValue),
1745
+ );
1746
+ };
1431
1747
  }
1432
1748
  if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
1433
- // TLC refuses action composition unless a Java property enables its incomplete implementation.
1434
1749
  if (expression.operator === "\\cdot" && args.length === 2) {
1435
1750
  return () => {
1436
1751
  throw new TlaEvaluationError(
@@ -1459,9 +1774,20 @@ const compileQuantifier = (
1459
1774
  environment: Environment,
1460
1775
  ): Evaluator => {
1461
1776
  const isForall = expression.kind === "Forall";
1462
- const description = isForall ? "the body of \\A" : "the body of \\E";
1463
1777
  const body = getEvaluator(expression.body, environment);
1464
1778
  const bound = expression.bounds[0];
1779
+ const coverage = environment.coverage;
1780
+ if (coverage) {
1781
+ return (context) => {
1782
+ const isFound = forEachChargedBinding(
1783
+ expression.bounds,
1784
+ context,
1785
+ coverage,
1786
+ (scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
1787
+ );
1788
+ return isFound ? !isForall : isForall;
1789
+ };
1790
+ }
1465
1791
  if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
1466
1792
  const name = bound.pattern.name;
1467
1793
  const set = getEvaluator(bound.set, environment);
@@ -1469,9 +1795,9 @@ const compileQuantifier = (
1469
1795
  const isFound = someElement(
1470
1796
  getQuantifierElements(set(context), bound.set, environment.runtime.version),
1471
1797
  (element) =>
1472
- expectBoolean(
1798
+ expectBooleanBody(
1473
1799
  body(withScope(context, bindValue(context.scope, name, element))),
1474
- description,
1800
+ expression,
1475
1801
  ) !== isForall,
1476
1802
  );
1477
1803
  return isFound ? !isForall : isForall;
@@ -1480,14 +1806,17 @@ const compileQuantifier = (
1480
1806
  const bounds = expression.bounds;
1481
1807
  if (bounds.every((item) => item.pattern.kind === "Name")) {
1482
1808
  const names = bounds.map((item) => (item.pattern.kind === "Name" ? item.pattern.name : ""));
1483
- const sets = bounds.map((item) => getEvaluator(item.set, environment));
1484
1809
  return (context) => {
1485
- const lists = sets.map((set, index) =>
1486
- getQuantifierElements(set(context), bounds[index].set, environment.runtime.version),
1810
+ const lists = mapBoundSets(bounds, (set) =>
1811
+ getQuantifierElements(
1812
+ getEvaluator(set, environment)(context),
1813
+ set,
1814
+ environment.runtime.version,
1815
+ ),
1487
1816
  );
1488
1817
  const visit = (index: number, scope: Scope | undefined): boolean => {
1489
1818
  if (index < 0) {
1490
- return expectBoolean(body(withScope(context, scope)), description) !== isForall;
1819
+ return expectBooleanBody(body(withScope(context, scope)), expression) !== isForall;
1491
1820
  }
1492
1821
  return someElement(lists[index], (element) =>
1493
1822
  visit(index - 1, bindValue(scope, names[index], element)),
@@ -1500,7 +1829,7 @@ const compileQuantifier = (
1500
1829
  const isFound = forEachBinding(
1501
1830
  bounds,
1502
1831
  context,
1503
- (scope) => expectBoolean(body(withScope(context, scope)), description) !== isForall,
1832
+ (scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
1504
1833
  );
1505
1834
  return isFound ? !isForall : isForall;
1506
1835
  };
@@ -1519,8 +1848,6 @@ const getBoundValue = (pattern: BoundPattern, scope: Scope | undefined) => {
1519
1848
  return binding?.kind === "Value" ? binding.value : undefined;
1520
1849
  };
1521
1850
 
1522
- // TLC keeps a function constructor lazy when it is the function of an application, or the base of
1523
- // an EXCEPT that is, so it evaluates the body only at the arguments it is applied to.
1524
1851
  const keptLazyExpressions = new WeakSet<Expression>();
1525
1852
 
1526
1853
  export const keepLazy = (expression: Expression) => {
@@ -1529,32 +1856,69 @@ export const keepLazy = (expression: Expression) => {
1529
1856
  }
1530
1857
  };
1531
1858
 
1532
- const compileFunctionConstruction = (
1859
+ const scopeNames = new WeakMap<Expression, string[] | undefined>();
1860
+
1861
+ const getScopeNames = (expression: Expression) => {
1862
+ if (scopeNames.has(expression)) return scopeNames.get(expression);
1863
+ const names = new Set<string>();
1864
+ const visit = (node: Expression): boolean => {
1865
+ if (node.kind === "Subexpression") return false;
1866
+ const name = getReferencedName(node);
1867
+ if (name !== undefined) names.add(name);
1868
+ if (node.kind === "ExceptAt") names.add(EXCEPT_AT);
1869
+ return getChildren(node).every(visit);
1870
+ };
1871
+ const result = visit(expression) ? [...names] : undefined;
1872
+ scopeNames.set(expression, result);
1873
+ return result;
1874
+ };
1875
+
1876
+ const trimScope = (scope: Scope | undefined, names: string[] | undefined) =>
1877
+ names === undefined || scope === undefined
1878
+ ? scope
1879
+ : names.reduce<Scope>(
1880
+ (trimmed, name) => {
1881
+ const binding = lookupScope(scope, name);
1882
+ return binding ? { name, binding, parent: trimmed } : trimmed;
1883
+ },
1884
+ { name: "", binding: { kind: "Value", value: false }, parent: undefined },
1885
+ );
1886
+
1887
+ export const isKeptLazy = (expression: Expression) => keptLazyExpressions.has(expression);
1888
+
1889
+ export const getFunctionBuilder = (
1533
1890
  expression: Expression & { kind: "FunctionConstruction" },
1534
1891
  environment: Environment,
1535
- ): Evaluator => {
1536
- const isKeptLazy = keptLazyExpressions.has(expression);
1892
+ ) => {
1893
+ const isKeptLazyExpression = isKeptLazy(expression);
1537
1894
  const body = getEvaluator(expression.body, environment);
1538
1895
  const bounds = expression.bounds;
1539
1896
  const bound = bounds[0];
1540
1897
  const isSingleName = bounds.length === 1 && bound.pattern.kind === "Name";
1541
- const set = getEvaluator(bound.set, environment);
1542
1898
  const construct = (domain: Value, context: Context) => {
1543
1899
  if (isSingleName && bound.pattern.kind === "Name") {
1544
1900
  const name = bound.pattern.name;
1901
+ const evaluateAt = (key: Value) =>
1902
+ body(withScope(context, bindValue(context.scope, name, key)));
1903
+ // TLC sizes the domain and evaluates the body at each element of a domain too large to hold.
1904
+ if (isBeyondSetBound(domain)) {
1905
+ getCardinality(domain);
1906
+ forEachElement(domain, evaluateAt);
1907
+ return createLazy(domain, context);
1908
+ }
1545
1909
  const keys = getFunctionDomain(domain);
1546
- const functionValue = createSortedFunction(
1547
- keys,
1548
- keys.map((key) => body(withScope(context, bindValue(context.scope, name, key)))),
1549
- );
1550
- // FcnLambdaValue#toFcnRcd builds a FcnRcdValue over an interval or an enumerated set.
1551
- return isReducibleSet(domain) ? functionValue : markLambdaFunction(functionValue);
1910
+ const functionValue = createSortedFunction(keys, keys.map(evaluateAt));
1911
+ if (isReducibleSet(domain)) return functionValue;
1912
+ functionValue.lambdaDomain = domain;
1913
+ return markLambdaFunction(functionValue);
1552
1914
  }
1553
1915
  const pairs: [Value, Value][] = [];
1554
- const sets = bounds.map((item) =>
1916
+ const sets = mapBoundSets(bounds, (set, index) =>
1555
1917
  getNormalizedElements(
1556
- evaluate(item.set, context),
1557
- item.set,
1918
+ bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
1919
+ ? domain.factors[index]
1920
+ : domain,
1921
+ set,
1558
1922
  context.environment.runtime.version,
1559
1923
  ),
1560
1924
  );
@@ -1569,13 +1933,26 @@ const compileFunctionConstruction = (
1569
1933
  return createFunction(pairs);
1570
1934
  };
1571
1935
  const template = getLazyFunctionTemplate(bounds, expression.body);
1936
+ const boundTupleLengths = getBoundTupleLengths(bounds);
1937
+ const bodyNames = getScopeNames(expression.body);
1938
+ const coverage = environment.coverage;
1572
1939
  const createLazy = (domain: Value, context: Context) => {
1573
- const scope = context.scope;
1940
+ const scope = trimScope(context.scope, bodyNames);
1941
+ const lambdaContext = withScope(context, scope);
1942
+ const compute = (argument: Value) =>
1943
+ body(withScope(lambdaContext, bindArgument(bounds, scope, argument)));
1944
+ const node = coverage && !environment.callStack ? coverage.current : -1;
1574
1945
  const functionValue = keepLambda({
1575
1946
  value: createLazyFunction(
1576
1947
  domain,
1577
- (argument) => body(withScope(context, bindArgument(bounds, scope, argument))),
1948
+ coverage
1949
+ ? (argument) =>
1950
+ coverage.current === -1
1951
+ ? compute(argument)
1952
+ : runAtCoverageNode(coverage, node, () => compute(argument))
1953
+ : compute,
1578
1954
  getLazyFunctionSource(template, bounds, domain),
1955
+ boundTupleLengths,
1579
1956
  ),
1580
1957
  bounds,
1581
1958
  body: expression.body,
@@ -1584,15 +1961,22 @@ const compileFunctionConstruction = (
1584
1961
  return bounds.length === 1 ? markLambdaFunction(functionValue) : functionValue;
1585
1962
  };
1586
1963
  const callStack = environment.callStack;
1587
- return (context) => {
1588
- const domain = isSingleName ? set(context) : getBoundsDomain(bounds, context);
1589
- if (expression.isRecursive || isKeptLazy || context.isKeepLazy || !isEnumerable(domain)) {
1964
+ const build = (domain: Value, context: Context) => {
1965
+ if (
1966
+ expression.isRecursive ||
1967
+ isKeptLazyExpression ||
1968
+ context.isKeepLazy ||
1969
+ !isEnumerable(domain)
1970
+ ) {
1590
1971
  return createLazy(domain, context);
1591
1972
  }
1592
- // TLC builds a function over a domain other than a set enumeration or an interval lazily, so
1593
- // its body fails only where TLC forces it, as the replay does. Building it at once is faster
1594
- // otherwise.
1595
- if (!isReducibleSet(domain)) {
1973
+ const isReducibleDomain =
1974
+ bounds.length === 1
1975
+ ? isReducibleSet(domain)
1976
+ : typeof domain === "object" &&
1977
+ domain.kind === "ProductSet" &&
1978
+ domain.factors.every(isReducibleSet);
1979
+ if (!isReducibleDomain) {
1596
1980
  if (callStack) return createLazy(domain, context);
1597
1981
  try {
1598
1982
  return construct(domain, context);
@@ -1602,7 +1986,6 @@ const compileFunctionConstruction = (
1602
1986
  }
1603
1987
  }
1604
1988
  if (!callStack) return construct(domain, context);
1605
- // TLC builds the function in a method of the FcnLambdaValue that CallStackTool gives a source.
1606
1989
  try {
1607
1990
  return construct(domain, context);
1608
1991
  } catch (error) {
@@ -1610,14 +1993,45 @@ const compileFunctionConstruction = (
1610
1993
  throw error;
1611
1994
  }
1612
1995
  };
1996
+ return { build, createLazy };
1997
+ };
1998
+
1999
+ const compileFunctionConstruction = (
2000
+ expression: Expression & { kind: "FunctionConstruction" },
2001
+ environment: Environment,
2002
+ ): Evaluator => {
2003
+ const build = getFunctionBuilder(expression, environment).build;
2004
+ const bounds = expression.bounds;
2005
+ const coverage = environment.coverage;
2006
+ if (coverage) {
2007
+ return (context) => {
2008
+ const domain = getBoundsDomain(bounds, context);
2009
+ const value = build(domain, context);
2010
+ const sets =
2011
+ bounds.length === 1 || typeof domain !== "object" || domain.kind !== "ProductSet"
2012
+ ? [domain]
2013
+ : domain.factors;
2014
+ const isConverted =
2015
+ (typeof value !== "object" || value.kind !== "LazyFunction") && sets.every(isReducibleSet);
2016
+ if (isConverted && coverage.current !== -1 && coverage.covered.has(expression)) {
2017
+ chargeFunctionConstruction(coverage, coverage.current, sets);
2018
+ }
2019
+ return value;
2020
+ };
2021
+ }
2022
+ if (bounds.length === 1 && bounds[0].pattern.kind === "Name") {
2023
+ const set = getEvaluator(bounds[0].set, environment);
2024
+ return (context) => build(set(context), context);
2025
+ }
2026
+ return (context) => build(getBoundsDomain(bounds, context), context);
1613
2027
  };
1614
2028
 
1615
2029
  const compileExcept = (
1616
2030
  expression: Expression & { kind: "Except" },
1617
2031
  environment: Environment,
1618
2032
  ): Evaluator => {
1619
- const isKeptLazy = keptLazyExpressions.has(expression);
1620
- if (isKeptLazy) keepLazy(expression.function);
2033
+ const isKeptLazyExpression = keptLazyExpressions.has(expression);
2034
+ if (isKeptLazyExpression) keepLazy(expression.function);
1621
2035
  const evaluateFunction = getEvaluator(expression.function, environment);
1622
2036
  const updates = expression.updates.map((update) => ({
1623
2037
  path: update.path.map((step): CompiledStep =>
@@ -1650,19 +2064,18 @@ const compileExcept = (
1650
2064
  current,
1651
2065
  getKey(path[depth], context),
1652
2066
  (previous) => update(previous, path, depth + 1, context, value),
1653
- isKeptLazy && depth === 0,
2067
+ isKeptLazyExpression && depth === 0,
1654
2068
  );
1655
2069
  };
1656
2070
  return (context) => {
1657
2071
  let current = evaluateFunction(context);
1658
2072
  for (const item of updates) {
1659
- // TLC leaves the value as it is when an update's path is not in it, and warns.
1660
- const found = { value: false };
2073
+ let isFound = false;
1661
2074
  current = update(current, item.path, 0, context, (inner) => {
1662
- found.value = true;
2075
+ isFound = true;
1663
2076
  return item.value(inner);
1664
2077
  });
1665
- if (!found.value) {
2078
+ if (!isFound) {
1666
2079
  context.environment.runtime.warn(
1667
2080
  MESSAGE_CODE.exceptAppliedToUnknownField,
1668
2081
  `The EXCEPT was applied to non-existing fields of the value at\n${describeRange(expression.function)}`,
@@ -1673,6 +2086,119 @@ const compileExcept = (
1673
2086
  };
1674
2087
  };
1675
2088
 
2089
+ export const getLazyFilter = (
2090
+ expression: Expression & { kind: "SetFilter" },
2091
+ environment: Environment,
2092
+ ) => {
2093
+ const predicate = getEvaluator(expression.predicate, environment);
2094
+ const pattern = expression.bound.pattern;
2095
+ const predicateNode = describeNode(expression.predicate);
2096
+ const source = expression.predicate.location.range && {
2097
+ names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
2098
+ predicate: predicateNode,
2099
+ };
2100
+ const coverage = environment.coverage;
2101
+ const createFiltered = (
2102
+ base: Value,
2103
+ context: Context,
2104
+ evaluator: Evaluator,
2105
+ node: number,
2106
+ ): RebindableFilteredSet => {
2107
+ const test = (element: Value, isMember: boolean) => {
2108
+ if (
2109
+ pattern.kind === "Tuple" &&
2110
+ getSequenceElements(element)?.length !== pattern.names.length
2111
+ ) {
2112
+ throw new TlaEvaluationError(
2113
+ `Attempted to check if the value:\n${prettyPrint(formatValue(element))}\nis an element of a set of ${pattern.names.length}-tuples.`,
2114
+ );
2115
+ }
2116
+ const value = evaluator(withScope(context, bindPattern(context.scope, pattern, element)));
2117
+ if (typeof value !== "boolean") {
2118
+ throw new TlaEvaluationError(
2119
+ `${isMember ? "The evaluation of predicate" : "Evaluating predicate"} ${predicateNode} yielded non-Boolean value.`,
2120
+ );
2121
+ }
2122
+ return value;
2123
+ };
2124
+ const rebind = (tracing: Environment) =>
2125
+ createFiltered(
2126
+ base,
2127
+ { ...context, environment: tracing },
2128
+ getEvaluator(expression.predicate, tracing),
2129
+ -1,
2130
+ );
2131
+ if (!coverage || node === -1) return { kind: "FilteredSet", base, test, source, rebind };
2132
+ return {
2133
+ kind: "FilteredSet",
2134
+ base,
2135
+ test: (element, isMember) =>
2136
+ runAtCoverageNode(coverage, isMember ? -1 : node, () => test(element, isMember)),
2137
+ startPass: (isMaterialized) => {
2138
+ const draws = createProductSetEnumerator(coverage, base);
2139
+ return (element) => {
2140
+ draws?.next();
2141
+ tagSubset(coverage, base, element);
2142
+ coverage.secondary[node]++;
2143
+ const value = runAtCoverageNode(coverage, node, () => test(element, false));
2144
+ if (isMaterialized && value) coverage.secondary[node]++;
2145
+ return value;
2146
+ };
2147
+ },
2148
+ source,
2149
+ rebind,
2150
+ };
2151
+ };
2152
+ return (base: Value, context: Context, node = -1) =>
2153
+ createFiltered(base, context, predicate, node);
2154
+ };
2155
+
2156
+ const hasLocalName = (expression: Expression): boolean =>
2157
+ isLocallyResolved(expression) ||
2158
+ expression.kind === "OperatorReference" ||
2159
+ getChildren(expression).some(hasLocalName);
2160
+
2161
+ export const isUniformPredicate = (
2162
+ expression: Expression & { kind: "SetFilter" },
2163
+ environment: Environment,
2164
+ ) =>
2165
+ expression.bound.pattern.kind === "Name" &&
2166
+ !environment.coverage &&
2167
+ !hasLocalName(expression.predicate) &&
2168
+ !isExpressionImpure([expression.predicate], environment, "varying");
2169
+
2170
+ export const expectFilterPredicate = (
2171
+ value: Value,
2172
+ expression: Expression & { kind: "SetFilter" },
2173
+ ) => {
2174
+ if (typeof value !== "boolean") {
2175
+ throw new TlaEvaluationError(
2176
+ `Attempted to evaluate an expression of form {x \\in S : P(x)} when P was ${getKindString(value)}.\n${describeNode(expression.predicate)}`,
2177
+ );
2178
+ }
2179
+ return value;
2180
+ };
2181
+
2182
+ export const getChoiceElements = (
2183
+ base: Value,
2184
+ expression: Expression & { kind: "Choose" },
2185
+ set: Expression,
2186
+ version: TlcVersion,
2187
+ ) => {
2188
+ if (!isSetValue(base) || isOverriddenSet(base)) {
2189
+ throw new TlaEvaluationError(
2190
+ `Attempted to compute the value of an expression of\nform CHOOSE x \\in S: P, but S was not enumerable.\n${describeRange(expression)}`,
2191
+ );
2192
+ }
2193
+ normalizeShallowly(base);
2194
+ return getNormalizedElements(base, set, version);
2195
+ };
2196
+
2197
+ export const createNoChoiceError = (expression: Expression & { kind: "Choose" }) =>
2198
+ new TlaEvaluationError(
2199
+ `Attempted to compute the value of an expression of form\nCHOOSE x \\in S: P, but no element of S satisfied P.\n${describeRange(expression)}`,
2200
+ );
2201
+
1676
2202
  const compileSetComprehension = (
1677
2203
  expression: Expression & { kind: "SetFilter" | "SetMap" | "Choose" },
1678
2204
  environment: Environment,
@@ -1680,48 +2206,37 @@ const compileSetComprehension = (
1680
2206
  if (expression.kind === "SetFilter") {
1681
2207
  const predicate = getEvaluator(expression.predicate, environment);
1682
2208
  const set = getEvaluator(expression.bound.set, environment);
2209
+ const filterLazily = getLazyFilter(expression, environment);
1683
2210
  const pattern = expression.bound.pattern;
1684
- const range = expression.predicate.location.range;
1685
- const source = range && {
1686
- names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
1687
- predicate: formatRange(range),
1688
- };
1689
- const createTest = (evaluator: Evaluator, context: Context) => (element: Value) =>
1690
- expectBoolean(
1691
- evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
1692
- "a set filter predicate",
1693
- );
1694
- const createFiltered = (
1695
- base: Value,
1696
- context: Context,
1697
- evaluator: Evaluator,
1698
- ): RebindableFilteredSet => ({
1699
- kind: "FilteredSet",
1700
- base,
1701
- test: createTest(evaluator, context),
1702
- source,
1703
- rebind: (tracing) =>
1704
- createFiltered(
1705
- base,
1706
- { ...context, environment: tracing },
1707
- getEvaluator(expression.predicate, tracing),
1708
- ),
1709
- });
2211
+ const coverage = environment.coverage;
2212
+ const isUniform = isUniformPredicate(expression, environment);
1710
2213
  return (context) => {
1711
2214
  const base = set(context);
1712
- // TLC filters any value it can't enumerate lazily, and fails only when it uses the result.
1713
- if (!isReducibleSet(base)) return createFiltered(base, context, predicate);
1714
- return createSortedSet(toFiniteSet(base).elements.filter(createTest(predicate, context)));
2215
+ if (!isReducibleSet(base)) return filterLazily(base, context, coverage?.current);
2216
+ const kept: Value[] = [];
2217
+ const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
2218
+ const size = Array.isArray(elements) ? elements.length : elements.high - elements.low + 1;
2219
+ for (let position = 0; position < size; position++) {
2220
+ const element = Array.isArray(elements) ? elements[position] : elements.low + position;
2221
+ const value = predicate(withScope(context, bindPattern(context.scope, pattern, element)));
2222
+ if (expectFilterPredicate(value, expression)) addBoundedElement(kept, element);
2223
+ else if (isUniform) break;
2224
+ }
2225
+ if (coverage) costCoverage(coverage, base, size + 1);
2226
+ return createNormalizedSet(kept);
1715
2227
  };
1716
2228
  }
1717
2229
  if (expression.kind === "SetMap") {
1718
2230
  const mapped = getEvaluator(expression.expression, environment);
2231
+ const coverage = environment.coverage;
1719
2232
  return (context) => {
1720
2233
  const elements: Value[] = [];
1721
- forEachBinding(expression.bounds, context, (scope) => {
1722
- elements.push(mapped(withScope(context, scope)));
2234
+ const add = (scope: Scope | undefined) => {
2235
+ addBoundedElement(elements, mapped(withScope(context, scope)));
1723
2236
  return false;
1724
- });
2237
+ };
2238
+ if (coverage) forEachChargedBinding(expression.bounds, context, coverage, add);
2239
+ else forEachBinding(expression.bounds, context, add);
1725
2240
  return createEnumeratedSet(elements);
1726
2241
  };
1727
2242
  }
@@ -1729,37 +2244,40 @@ const compileSetComprehension = (
1729
2244
  if (!set) {
1730
2245
  return () => {
1731
2246
  throw new TlaEvaluationError(
1732
- `TLC cannot evaluate an unbounded CHOOSE at ${describeLocation(expression)}`,
2247
+ `TLC attempted to evaluate an unbounded CHOOSE.\nMake sure that the expression is of form CHOOSE x \\in S: P(x).\n${describeRange(expression)}`,
1733
2248
  );
1734
2249
  };
1735
2250
  }
1736
2251
  const body = getEvaluator(expression.body, environment);
1737
2252
  const evaluateSet = getEvaluator(set, environment);
2253
+ const coverage = environment.coverage;
1738
2254
  return (context) => {
1739
2255
  const base = evaluateSet(context);
1740
- if (!isSetValue(base) || isOverriddenSet(base)) {
1741
- throw new TlaEvaluationError(
1742
- `Attempted to compute the value of an expression of\nform CHOOSE x \\in S: P, but S was not enumerable.\n${describeRange(expression)}`,
1743
- );
1744
- }
1745
- const chosen = { value: undefined as Value | undefined };
1746
- const elements = getNormalizedElements(base, set, context.environment.runtime.version);
2256
+ const elements = getChoiceElements(base, expression, set, context.environment.runtime.version);
2257
+ const enumerator = coverage && createChargedEnumerator(coverage, base, elements, true);
2258
+ let chosen: Value | undefined;
2259
+ const pattern = expression.pattern;
1747
2260
  someElement(elements, (element) => {
1748
- const scope = bindPattern(context.scope, expression.pattern, element);
1749
- if (!expectBoolean(body(withScope(context, scope)), "the body of CHOOSE")) return false;
1750
- chosen.value = getBoundValue(expression.pattern, scope);
2261
+ enumerator?.next();
2262
+ if (
2263
+ pattern.kind === "Tuple" &&
2264
+ getSequenceElements(element)?.length !== pattern.names.length
2265
+ ) {
2266
+ throw new TlaEvaluationError(
2267
+ `Attempted to compute the value of an expression of form\nCHOOSE <<x1, ... , xN>> \\in S: P, but S was not a set\nof N-tuples.\n${describeRange(expression)}`,
2268
+ );
2269
+ }
2270
+ const scope = bindPattern(context.scope, pattern, element);
2271
+ if (!expectBooleanBody(body(withScope(context, scope)), expression)) return false;
2272
+ chosen = getBoundValue(pattern, scope);
1751
2273
  return true;
1752
2274
  });
1753
- if (chosen.value === undefined) {
1754
- throw new TlaEvaluationError(
1755
- `Attempted to compute the value of an expression of form\nCHOOSE x \\in S: P, but no element of S satisfied P.\n${describeRange(expression)}`,
1756
- );
1757
- }
1758
- return chosen.value;
2275
+ if (chosen !== undefined) return chosen;
2276
+ enumerator?.next();
2277
+ throw createNoChoiceError(expression);
1759
2278
  };
1760
2279
  };
1761
2280
 
1762
- // TLC orders a record's fields by name.
1763
2281
  export const getSortedFields = (fields: RecordField[]) =>
1764
2282
  [...fields].sort((left, right) => compareValues(left.name, right.name));
1765
2283
 
@@ -1768,20 +2286,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
1768
2286
 
1769
2287
  const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
1770
2288
  const fields = getSortedFields(recordFields);
1771
- const hasDuplicates = hasDuplicateFields(fields);
1772
- const values = fields.map((field) => getEvaluator(field.value, environment));
1773
- if (hasDuplicates) {
2289
+ const values = recordFields.map((field) => getEvaluator(field.value, environment));
2290
+ if (hasDuplicateFields(fields)) {
1774
2291
  return (context) =>
1775
2292
  createRecord(
1776
- fields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2293
+ recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
1777
2294
  );
1778
2295
  }
1779
2296
  const names = fields.map((field) => field.name);
1780
2297
  const writtenNames = recordFields.map((field) => field.name);
1781
2298
  if (writtenNames.some((name, index) => name !== names[index])) {
2299
+ const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
1782
2300
  return (context) =>
1783
2301
  createWrittenRecord(
1784
2302
  names,
2303
+ writtenIndexes,
1785
2304
  values.map((value) => value(context)),
1786
2305
  writtenNames,
1787
2306
  );
@@ -1831,48 +2350,38 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1831
2350
  };
1832
2351
  case "And": {
1833
2352
  const operands = expression.operands.map(getChildEvaluator);
1834
- return (context) => {
1835
- for (let index = 0; index < operands.length; index++) {
1836
- const value = operands[index](context);
1837
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
1838
- if (!value) return false;
1839
- }
1840
- return true;
1841
- };
2353
+ return (
2354
+ compileTracedJunction(expression, operands, environment.callStack) ??
2355
+ ((context) => {
2356
+ for (let index = 0; index < operands.length; index++) {
2357
+ const value = operands[index](context);
2358
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2359
+ if (!value) return false;
2360
+ }
2361
+ return true;
2362
+ })
2363
+ );
1842
2364
  }
1843
2365
  case "Or": {
1844
2366
  const operands = expression.operands.map(getChildEvaluator);
1845
- return (context) => {
1846
- for (let index = 0; index < operands.length; index++) {
1847
- const value = operands[index](context);
1848
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
1849
- if (value) return true;
1850
- }
1851
- return false;
1852
- };
2367
+ return (
2368
+ compileTracedJunction(expression, operands, environment.callStack) ??
2369
+ ((context) => {
2370
+ for (let index = 0; index < operands.length; index++) {
2371
+ const value = operands[index](context);
2372
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2373
+ if (value) return true;
2374
+ }
2375
+ return false;
2376
+ })
2377
+ );
1853
2378
  }
1854
2379
  case "Prime": {
1855
2380
  const inner = getChildEvaluator(expression.expression);
1856
- return (context) => {
1857
- if (!context.next) throw createPrimeOutsideActionError(expression);
1858
- return inner({
1859
- environment: context.environment,
1860
- scope: context.scope,
1861
- state: context.next,
1862
- next: undefined,
1863
- isKeepLazy: context.isKeepLazy,
1864
- });
1865
- };
1866
- }
1867
- case "Unchanged": {
1868
- const primed = getChildEvaluator({
1869
- kind: "Prime",
1870
- expression: expression.expression,
1871
- location: expression.location,
1872
- });
1873
- const current = getChildEvaluator(expression.expression);
1874
- return (context) => valuesEqual(primed(context), current(context));
2381
+ return (context) => inner(toNextContext(context));
1875
2382
  }
2383
+ case "Unchanged":
2384
+ return compileUnchanged(getChildEvaluator(expression.expression));
1876
2385
  case "If": {
1877
2386
  const condition = getChildEvaluator(expression.condition);
1878
2387
  const consequent = getChildEvaluator(expression.consequent);
@@ -1916,8 +2425,15 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1916
2425
  return compileQuantifier(expression, environment);
1917
2426
  case "UnboundedQuantifier":
1918
2427
  return () => {
2428
+ const operator = expression.quantifier === "Forall" ? "\\A" : "\\E";
2429
+ if (expression.isTemporal) {
2430
+ throw createTemporalFormulaError(
2431
+ expression.quantifier === "Forall" ? "\\AA" : "\\EE",
2432
+ expression,
2433
+ );
2434
+ }
1919
2435
  throw new TlaEvaluationError(
1920
- `TLC cannot evaluate an unbounded quantifier at ${describeLocation(expression)}`,
2436
+ `TLC attempted to evaluate an unbounded ${operator}.\nMake sure that the expression is of form ${operator} x \\in S: P(x).\n${describeRange(expression)}`,
1921
2437
  );
1922
2438
  };
1923
2439
  case "Choose":
@@ -1944,8 +2460,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1944
2460
  case "RecordSet": {
1945
2461
  const fields = getSortedFields(expression.fields);
1946
2462
  const names = fields.map((field) => field.name);
1947
- const sets = fields.map((field) => getChildEvaluator(field.value));
1948
- return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2463
+ const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
2464
+ const sets = expression.fields.map((field) => getChildEvaluator(field.value));
2465
+ if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
2466
+ return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2467
+ }
2468
+ return (context) => {
2469
+ const writtenSets = sets.map((set) => set(context));
2470
+ return {
2471
+ kind: "RecordSet",
2472
+ names,
2473
+ sets: writtenIndexes.map((index) => writtenSets[index]),
2474
+ };
2475
+ };
1949
2476
  }
1950
2477
  case "Except":
1951
2478
  return compileExcept(expression, environment);
@@ -1993,16 +2520,18 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1993
2520
  case "BoxAction":
1994
2521
  case "AngleAction": {
1995
2522
  const action = getChildEvaluator(expression.action);
1996
- const unchanged = getChildEvaluator({
1997
- kind: "Unchanged",
1998
- expression: expression.subscript,
1999
- location: expression.location,
2000
- });
2523
+ const unchanged = compileUnchanged(getChildEvaluator(expression.subscript));
2001
2524
  const isBox = expression.kind === "BoxAction";
2002
- return (context) =>
2003
- isBox
2004
- ? expectBoolean(action(context), "an action") || unchanged(context)
2005
- : expectBoolean(action(context), "an action") && !unchanged(context);
2525
+ const form = isBox ? "[A]_e" : "<A>_e";
2526
+ return (context) => {
2527
+ const value = action(context);
2528
+ if (typeof value !== "boolean") {
2529
+ throw new TlaEvaluationError(
2530
+ `Attempted to evaluate an expression of form ${form}, but A was not a boolean.\n${describeRange(expression)}`,
2531
+ );
2532
+ }
2533
+ return isBox ? value || unchanged(context) : value && !unchanged(context);
2534
+ };
2006
2535
  }
2007
2536
  case "Enabled": {
2008
2537
  const action = expression.expression;
@@ -2010,6 +2539,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2010
2539
  }
2011
2540
  case "Label":
2012
2541
  return getChildEvaluator(expression.body);
2542
+ case "Selection":
2543
+ return getChildEvaluator(expression.expression);
2013
2544
  case "Subexpression":
2014
2545
  return () => {
2015
2546
  throw new TlaEvaluationError(
@@ -2021,9 +2552,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2021
2552
  case "WeakFairness":
2022
2553
  case "StrongFairness":
2023
2554
  return () => {
2024
- throw new TlaEvaluationError(
2025
- `TLC cannot evaluate a temporal formula in a state at ${describeLocation(expression)}`,
2026
- );
2555
+ throw createTemporalFormulaError(TEMPORAL_FORMS[expression.kind], expression);
2027
2556
  };
2028
2557
  }
2029
2558
  };