tla-ts 0.0.9-dev.8298a52 → 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 +8 -0
  2. package/dist/compile.cjs +6 -6
  3. package/dist/compile.js +10 -10
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +57 -53
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +121 -12
  8. package/dist/index.d.ts +121 -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 +1 -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 +1155 -900
  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 +318 -656
  41. package/src/cli/typescript.ts +0 -3
  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 +260 -371
  51. package/src/errors.ts +93 -58
  52. package/src/evaluate.ts +848 -374
  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 +97 -43
  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 -325
  64. package/src/liveness.ts +224 -131
  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 +34 -57
  88. package/src/parallel.ts +62 -72
  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 +129 -38
  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 +296 -105
  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 +10 -25
  612. package/src/typescript/collections.ts +34 -35
  613. package/src/typescript/compile.ts +1 -8
  614. package/src/typescript/context.ts +0 -12
  615. package/src/typescript/emit.ts +0 -1
  616. package/src/typescript/expressions.ts +0 -12
  617. package/src/typescript/formula.ts +9 -15
  618. package/src/typescript/functions.ts +6 -17
  619. package/src/typescript/model.ts +14 -16
  620. package/src/typescript/names.ts +0 -2
  621. package/src/typescript/program.ts +0 -3
  622. package/src/typescript/properties.ts +6 -8
  623. package/src/typescript/scope.ts +0 -5
  624. package/src/typescript/steps.ts +20 -28
  625. package/src/typescript/types.ts +3 -10
  626. package/src/values.ts +917 -522
  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,14 +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;
122
- // Whether the thunk dropped its scope after caching a value that holds in every state.
123
144
  isReleased?: boolean;
124
145
  }
125
146
 
126
- 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 };
127
151
 
128
152
  export interface Scope {
129
153
  name: string;
@@ -137,55 +161,37 @@ export interface Environment {
137
161
  builtins: Map<string, Builtin>;
138
162
  constants: Map<string, Value>;
139
163
  substitutions: Map<string, string>;
140
- // The name SANY gives each definition that a named instance such as `M == INSTANCE Module`
141
- // copies, such as M!Op, by the key of the copy.
142
164
  instanceNames: Map<string, string>;
143
165
  variables: string[];
144
166
  variableIndex: Map<string, number>;
145
167
  facts: DefinitionFacts;
146
- // The value of each constant definition TLC computed when it started, by the definition's id in
147
- // facts. TLC evaluates a definition it failed to compute where the spec uses it.
148
168
  startupValues: (Value | undefined)[];
149
- // The definitions an INSTANCE copies from a module that declares constants or variables. SANY
150
- // wraps the body of each in its substitutions.
169
+ tlcEvalValues: WeakMap<Expression, Value>;
151
170
  substitutedDefinitions: Set<Definition>;
152
- // The compiled code of each expression, of each expression evaluated as a whole, which generated
153
- // code can serve, and of each reference to a definition.
171
+ instanceParams: Set<OperatorParam>;
154
172
  evaluators: WeakMap<Expression, Evaluator>;
155
173
  entryEvaluators: WeakMap<Expression, Evaluator>;
156
174
  definitionEvaluators: WeakMap<Definition, Evaluator>;
157
- // The expressions being evaluated, outermost first, when the environment replays an error to
158
- // find where it occurred, as TLC's CallStackTool does.
159
175
  callStack?: CallStack;
176
+ coverage?: Coverage;
160
177
  }
161
178
 
162
179
  export interface CallStack {
163
180
  expressions: Expression[];
164
- // TLC stops popping the stack once an evaluation fails, so it keeps where the failure occurred.
165
181
  isFrozen: boolean;
166
- // The expression that built each value of the replay that TLC's CallStackTool gives a source.
167
182
  sources: WeakMap<ObjectValue, Expression>;
168
- // The value each expression of the replay last evaluated to.
169
183
  values: WeakMap<Expression, Value>;
170
- // The expression each failure last left, which tells a failure of an operand from one of the
171
- // method that computes the operator.
172
184
  failures: WeakMap<Error, Expression>;
173
- // The failure of a value with a source, which TLC raises as a FingerprintException.
174
185
  fingerprint?: FingerprintFailure;
175
186
  }
176
187
 
177
188
  export interface FingerprintFailure {
178
- // The sources of the values whose methods failed, outermost first.
179
189
  sources: Expression[];
180
- // The message of the error the innermost one raised.
181
190
  reason: string;
182
191
  }
183
192
 
184
- // The operators of Tool#evalAppl whose value TLC's CallStackTool gives a source.
185
193
  const SOURCED_OPERATORS = new Set(["SUBSET", "UNION", "DOMAIN", "\\cup", "\\cap", "\\"]);
186
194
 
187
- // CallStackTool copies the SetPredValue, FcnLambdaValue and OpLambdaValue that an evaluation
188
- // returns without their source, and a function TLC builds from a FcnLambdaValue has none.
189
195
  const SOURCED_KINDS = new Set<Expression["kind"]>([
190
196
  "SetEnumeration",
191
197
  "SetFilter",
@@ -201,8 +207,6 @@ const isSourced = (expression: Expression) =>
201
207
  SOURCED_KINDS.has(expression.kind) ||
202
208
  (expression.kind === "Apply" && SOURCED_OPERATORS.has(expression.operator));
203
209
 
204
- // The argument whose method Tool#evalAppl calls to compute an operator, as with S.member(e) for
205
- // 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.
206
210
  const getReceiver = (expression: Expression, values: CallStack["values"]) => {
207
211
  if (expression.kind === "FunctionApplication" || expression.kind === "Except") {
208
212
  return expression.function;
@@ -223,8 +227,6 @@ export interface Context {
223
227
  scope: Scope | undefined;
224
228
  state: State | undefined;
225
229
  next: State | undefined;
226
- // EvalControl.KeepLazy, which Tool#evalAppl sets to evaluate the function it applies and which
227
- // the evaluation passes on, so that a function constructor within builds a FcnLambdaValue.
228
230
  isKeepLazy?: boolean;
229
231
  }
230
232
 
@@ -248,15 +250,23 @@ const EXCEPT_AT = "@";
248
250
  export const describeLocation = (expression: Expression) =>
249
251
  `line ${expression.location.line}, column ${expression.location.column}`;
250
252
 
251
- export const formatRange = (range: SourceRange) =>
252
- `line ${range.start.line}, col ${range.start.column} to line ${range.end.line}, col ${range.end.column} of module ${range.module}`;
253
-
254
253
  export const describeRange = (expression: Expression) => {
255
254
  const range = expression.location.range;
256
255
  return range ? formatRange(range) : describeLocation(expression);
257
256
  };
258
257
 
259
- // 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
+
260
270
  export const describeNode = (expression: Expression) =>
261
271
  expression.kind === "Number"
262
272
  ? (expression.text ?? String(expression.value))
@@ -267,8 +277,6 @@ export const createConditionError = (expression: Expression, value: Value) =>
267
277
  `A non-boolean expression (${getKindString(value)}) was used as the condition of an IF.\n${describeRange(expression)}`,
268
278
  );
269
279
 
270
- // TLC parses an infix chain of /\ or \/ as nested binary junctions and a bulleted list as one
271
- // junction list, and it words the error differently for each.
272
280
  export const createJunctionError = (
273
281
  expression: Expression & { kind: "And" | "Or" },
274
282
  index: number,
@@ -289,12 +297,10 @@ export const createJunctionError = (
289
297
  );
290
298
  };
291
299
 
292
- // TLC selects a field of a record, and of another function from the function it converts it to,
293
- // which for a tuple keeps its domain as an interval.
294
300
  export const getFieldSelector = (expression: Expression & { kind: "FieldAccess" }) => {
295
301
  const field = expression.field;
296
302
  const describeMissing = (record: Value) =>
297
- `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)}`;
298
304
  const describeNotInDomain = (functionValue: Value) =>
299
305
  `Attempted to apply function:\n${prettyPrint(formatValue(functionValue))}\nto argument "${field}", which is not in the domain of the function.`;
300
306
  return (value: Value) => {
@@ -305,17 +311,14 @@ export const getFieldSelector = (expression: Expression & { kind: "FieldAccess"
305
311
  }
306
312
  const functionClass = getFunctionClass(value);
307
313
  if (functionClass === "tuple") throw createNonIntegerKeyError(field);
308
- // Only TLC's RecordValue names the field it lacks. Any other function, such as a FcnRcdValue
309
- // whose keys are strings, reports an argument outside its domain.
310
314
  return applyFunction(
311
- value,
315
+ value.kind === "LazyFunction" ? toFiniteFunction(value) : value,
312
316
  field,
313
317
  functionClass === "record" ? describeMissing : describeNotInDomain,
314
318
  );
315
319
  };
316
320
  };
317
321
 
318
- // TLC 1.7.4 words what a tuple or a record lacks differently.
319
322
  export const getMissingArgumentDescriber = (version: TlcVersion | undefined) =>
320
323
  version === "1.7.4"
321
324
  ? (functionValue: Value, argument: Value) =>
@@ -332,41 +335,36 @@ export const getDomainOperator = (expression: Expression) => (value: Value) => {
332
335
  };
333
336
 
334
337
  export const getSubsetOperator =
335
- (expression: Expression, builtin: Builtin) => (left: Value, right: Value) => {
338
+ (expression: Expression, subset: (left: Value, right: Value) => Value) =>
339
+ (left: Value, right: Value) => {
336
340
  if (!isSetValue(left) || isOverriddenSet(left)) {
337
341
  throw new TlaEvaluationError(
338
342
  `Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
339
343
  );
340
344
  }
341
- return builtin.evaluate([left, right]);
345
+ return subset(left, right);
342
346
  };
343
347
 
344
- // TLC rejects a decimal, or an integer literal too big for it, while it processes the spec.
345
348
  export const createRealNumberError = (expression: DecimalExpression) =>
346
349
  setExitCode(
347
- new TlaEvaluationError(
348
- `TLC can't handle real numbers: ${expression.text} at ${describeLocation(expression)}`,
349
- ),
350
+ new TlaEvaluationError(`TLC can't handle real numbers.\n${expression.text}`),
350
351
  EXIT_STATUS.configParseError,
351
352
  );
352
353
 
353
354
  export const createBigNumberError = (expression: NumberExpression) =>
354
355
  setExitCode(
355
356
  new TlaEvaluationError(
356
- `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}`,
357
358
  ),
358
359
  EXIT_STATUS.error,
359
360
  );
360
361
 
361
- // TLC's Tool#evalAppl fails to look up a variable the state doesn't assign.
362
362
  export const createUnassignedError = (name: string, expression: Expression) =>
363
363
  new TlaUnassignedError(
364
364
  `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
365
365
  name,
366
366
  );
367
367
 
368
- // TLC's Tool#enabled reads the subscript of <<A>>_v in the successor as a state of its own, and
369
- // names the fairness condition when A leaves a variable of v unassigned, unlike TLC 1.7.4's.
370
368
  export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion | undefined) =>
371
369
  error instanceof TlaUnassignedError && version !== "1.7.4"
372
370
  ? new TlaEvaluationError(
@@ -374,11 +372,6 @@ export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion
374
372
  )
375
373
  : error;
376
374
 
377
- export const createPrimeOutsideActionError = (expression: Expression) =>
378
- new TlaEvaluationError(
379
- `A primed expression appears outside an action at ${describeLocation(expression)}`,
380
- );
381
-
382
375
  export const lookupScope = (scope: Scope | undefined, name: string): Binding | undefined => {
383
376
  for (let current = scope; current; current = current.parent) {
384
377
  if (current.name === name) return current.binding;
@@ -392,12 +385,13 @@ export const bindValue = (scope: Scope | undefined, name: string, value: Value):
392
385
  parent: scope,
393
386
  });
394
387
 
395
- const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Value) => {
388
+ export const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Value) => {
396
389
  if (pattern.kind === "Name") return bindValue(scope, pattern.name, value);
397
390
  const elements = getSequenceElements(value);
398
391
  if (!elements || elements.length !== pattern.names.length) {
392
+ const range = pattern.ranges?.[0];
399
393
  throw new TlaEvaluationError(
400
- `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) : ""}`,
401
395
  );
402
396
  }
403
397
  return pattern.names.reduce<Scope | undefined>(
@@ -406,7 +400,6 @@ const bindPattern = (scope: Scope | undefined, pattern: BoundPattern, value: Val
406
400
  );
407
401
  };
408
402
 
409
- // Tool#evalAppl checks that it applies a function before it evaluates the argument.
410
403
  export const expectFunction = (value: Value, application: Expression) => {
411
404
  if (isFunctionValue(value)) return value;
412
405
  throw new TlaEvaluationError(
@@ -442,6 +435,42 @@ export const expectBoolean = (value: Value, description: string) => {
442
435
  return value;
443
436
  };
444
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
+
445
474
  export const getDefinition = (name: string, environment: Environment) =>
446
475
  environment.definitions.get(environment.substitutions.get(name) ?? name);
447
476
 
@@ -461,12 +490,9 @@ const getBoundExplanation = (set: Value, text: string) => {
461
490
  return undefined;
462
491
  };
463
492
 
464
- // TLC enumerates every set except the ones it implements in Java, so any other set fails as its own
465
- // class does.
466
493
  const checkEnumerable = (set: Value, expression: Expression, version: TlcVersion) => {
467
494
  if (!isSetValue(set) || isOverriddenSet(set)) {
468
495
  const text = formatValue(set);
469
- // TLC 1.7.4 doesn't explain why it can't enumerate a set.
470
496
  const explanation = version === "1.7.4" ? undefined : getBoundExplanation(set, text);
471
497
  throw new TlaEvaluationError(
472
498
  explanation === undefined
@@ -482,16 +508,12 @@ const getEnumeratedElements = (set: Value, expression: Expression, version: TlcV
482
508
  return getLazySubsets(set) ?? getNormalizedSetElements(set);
483
509
  };
484
510
 
485
- // The elements Tool.contexts binds to the bound of a quantifier or a set map. TLC 1.7.4 streams a
486
- // lazy set's elements, where later versions normalize the set first.
487
511
  export const getContextElements = (set: Value, expression: Expression, version: TlcVersion) => {
488
512
  if (version !== "1.7.4") return getEnumeratedElements(set, expression, version);
489
513
  checkEnumerable(set, expression, version);
490
514
  return getLazySubsets(set) ?? getStreamedElements(set);
491
515
  };
492
516
 
493
- // Like TLC, a quantifier keeps an interval as an interval, so that it can stop at the first witness
494
- // in a large interval such as 1..2000000000 without listing it.
495
517
  const getKeptInterval = (set: Value) => {
496
518
  if (typeof set !== "object" || set.kind !== "Interval") return undefined;
497
519
  getCardinality(set);
@@ -501,7 +523,6 @@ const getKeptInterval = (set: Value) => {
501
523
  export const getQuantifierElements = (set: Value, expression: Expression, version: TlcVersion) =>
502
524
  getKeptInterval(set) ?? getContextElements(set, expression, version);
503
525
 
504
- // CHOOSE and a function constructor visit the elements of the normalized set.
505
526
  const getNormalizedElements = (set: Value, expression: Expression, version: TlcVersion) =>
506
527
  getKeptInterval(set) ?? getEnumeratedElements(set, expression, version);
507
528
 
@@ -516,16 +537,22 @@ const someElement = (
516
537
  return false;
517
538
  };
518
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
+
519
551
  export const getBoundElements = (bounds: Bound[], context: Context) =>
520
- bounds.map((bound) =>
521
- getQuantifierElements(
522
- evaluate(bound.set, context),
523
- bound.set,
524
- context.environment.runtime.version,
525
- ),
552
+ mapBoundSets(bounds, (set) =>
553
+ getQuantifierElements(evaluate(set, context), set, context.environment.runtime.version),
526
554
  );
527
555
 
528
- // Visits each binding of the bounds to the elements of their sets, until visit returns true.
529
556
  export const forEachBoundElement = (
530
557
  bounds: Bound[],
531
558
  sets: ReturnType<typeof getBoundElements>,
@@ -547,8 +574,33 @@ export const forEachBinding = (
547
574
  visit: (scope: Scope | undefined) => boolean,
548
575
  ) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
549
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
+
550
602
  const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
551
- const sets = bounds.map((bound) => evaluate(bound.set, context));
603
+ const sets = mapBoundSets(bounds, (set) => evaluate(set, context));
552
604
  return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
553
605
  };
554
606
 
@@ -561,8 +613,6 @@ const bindArgument = (bounds: Bound[], scope: Scope | undefined, argument: Value
561
613
  );
562
614
  };
563
615
 
564
- // The parameters, body and scope of each function a constructor or a definition keeps lazy, whose
565
- // body TLC's getInitStates and getNextStates walk for an argument, as they do a FcnLambdaValue's.
566
616
  interface LazyFunction {
567
617
  value: LazyFunctionValue;
568
618
  bounds: Bound[];
@@ -570,8 +620,7 @@ interface LazyFunction {
570
620
  scope: Scope | undefined;
571
621
  }
572
622
 
573
- // The function keeps its parameters, body and scope itself, since a WeakMap entry for each
574
- // 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.
575
624
  interface KeptLazyFunctionValue extends LazyFunctionValue {
576
625
  lambda: LazyFunction;
577
626
  }
@@ -584,8 +633,6 @@ const keepLambda = (lambda: LazyFunction) => Object.assign(lambda.value, { lambd
584
633
  export const getLazyFunction = (value: Value) =>
585
634
  isKeptLazyFunction(value) ? value.lambda : undefined;
586
635
 
587
- // Tool.getFcnContext: the scope of a lazy function's body for the arguments of an application. It
588
- // ignores arguments beyond the parameters.
589
636
  export const bindLazyArguments = (
590
637
  lambda: LazyFunction,
591
638
  expression: Expression & { kind: "FunctionApplication" },
@@ -610,12 +657,18 @@ export const bindLazyArguments = (
610
657
  typeof value.domain === "object" && value.domain.kind === "ProductSet"
611
658
  ? value.domain.factors
612
659
  : [];
613
- if (elements === undefined || elements.length < bounds.length) {
660
+ if (elements === undefined) {
614
661
  throw new TlaEvaluationError(
615
662
  `Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
616
663
  );
617
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
+ );
618
670
  bounds.forEach((bound, index) => {
671
+ if (index >= elements.length) throw createListError();
619
672
  const element = elements[index];
620
673
  const ordinal = `argument number ${index + 1}`;
621
674
  if (!isElementOf(element, domains[index])) {
@@ -636,11 +689,10 @@ export const bindLazyArguments = (
636
689
  );
637
690
  }
638
691
  });
639
- 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);
640
694
  };
641
695
 
642
- // TLC prints a function it can't enumerate as its parameters and the location of its body. It
643
- // prints only the first name of a group such as `m, n \in S`.
644
696
  interface LazyFunctionTemplate {
645
697
  parameters: { index: number; name: string }[];
646
698
  body: string;
@@ -663,7 +715,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
663
715
  },
664
716
  ],
665
717
  ),
666
- body: formatRange(range),
718
+ body: describeNode(body),
667
719
  };
668
720
  };
669
721
 
@@ -686,22 +738,29 @@ const getLazyFunctionSource = (
686
738
  };
687
739
  };
688
740
 
689
- // TLC's FcnLambdaValue evaluates its body at each application.
690
741
  const createLazyFunction = (
691
742
  domain: Value,
692
743
  compute: (argument: Value, self: LazyFunctionValue) => Value,
693
744
  source: LazyFunctionSource | undefined,
745
+ boundTupleLengths: (number | undefined)[] | undefined,
694
746
  ) => {
695
747
  const self: LazyFunctionValue = {
696
748
  kind: "LazyFunction",
697
749
  domain,
698
750
  source,
751
+ boundTupleLengths,
699
752
  apply: (argument) => compute(argument, self),
700
753
  };
701
754
  return self;
702
755
  };
703
756
 
704
- // 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
+
705
764
  const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
706
765
  kind: "FunctionConstruction",
707
766
  bounds: definition.bounds,
@@ -709,7 +768,10 @@ const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
709
768
  location: definition.location,
710
769
  });
711
770
 
712
- const createRecursiveFunction = (definition: FunctionDefinition, context: Context) => {
771
+ const createRecursiveFunction = (
772
+ definition: FunctionDefinition,
773
+ context: Context,
774
+ ): RebindableLazyFunction => {
713
775
  const domain = getBoundsDomain(definition.bounds, context);
714
776
  const functionValue = createLazyFunction(
715
777
  domain,
@@ -726,6 +788,7 @@ const createRecursiveFunction = (definition: FunctionDefinition, context: Contex
726
788
  definition.bounds,
727
789
  domain,
728
790
  ),
791
+ getBoundTupleLengths(definition.bounds),
729
792
  );
730
793
  keepLambda({
731
794
  value: functionValue,
@@ -733,11 +796,16 @@ const createRecursiveFunction = (definition: FunctionDefinition, context: Contex
733
796
  body: definition.body,
734
797
  scope: bindValue(undefined, definition.name, functionValue),
735
798
  });
736
- 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;
737
807
  };
738
808
 
739
- // TLC computes a constant definition when it starts, without keeping a function it constructs
740
- // lazy, so a function over an interval or an enumerated set is a FcnRcdValue.
741
809
  const toStartupValue = (definition: Definition, value: Value): Value => {
742
810
  if (typeof value !== "object" || getFunctionClass(value) !== "lambda") return value;
743
811
  if (
@@ -752,14 +820,11 @@ const toStartupValue = (definition: Definition, value: Value): Value => {
752
820
  const finite = toFiniteFunction(value);
753
821
  return createSortedFunction(finite.domain, finite.range);
754
822
  } catch (error) {
755
- // TLC leaves a definition it fails to compute to evaluate where the spec uses it.
756
823
  if (error instanceof TlaEvaluationError) return value;
757
824
  throw error;
758
825
  }
759
826
  };
760
827
 
761
- // The code of a definition's body, evaluated as a whole. TLC evaluates a function definition that
762
- // isn't recursive as it does a function constructor.
763
828
  const compileDefinitionBody = (definition: Definition, environment: Environment): Evaluator => {
764
829
  if (definition.kind === "Operator" && definition.params.length > 0) {
765
830
  return () => {
@@ -774,57 +839,92 @@ const compileDefinitionBody = (definition: Definition, environment: Environment)
774
839
  return getEntryEvaluator(getDefinitionSource(definition), environment);
775
840
  };
776
841
 
777
- // The code that evaluates a reference to a definition: the value TLC computed at startup when it
778
- // 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
+
779
848
  const getDefinitionEvaluator = (definition: Definition, environment: Environment): Evaluator => {
780
849
  const compiled = environment.definitionEvaluators.get(definition);
781
850
  if (compiled) return compiled;
782
851
  const body = compileDefinitionBody(definition, environment);
783
- const id = environment.facts.ids.get(definition);
852
+ const definitionId = environment.facts.ids.get(definition);
784
853
  const startupValues = environment.startupValues;
785
- const evaluator: Evaluator =
786
- 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
787
863
  ? (context) => body(withScope(context, undefined))
788
- : (context) => startupValues[id] ?? body(withScope(context, undefined));
864
+ : (context) => startupValues[definitionId] ?? body(withScope(context, undefined));
789
865
  environment.definitionEvaluators.set(definition, evaluator);
790
866
  return evaluator;
791
867
  };
792
868
 
793
869
  export const getStartupValue = (definition: Definition, environment: Environment) => {
794
- const id = environment.facts.ids.get(definition);
795
- return id === undefined ? undefined : environment.startupValues[id];
870
+ const definitionId = environment.facts.ids.get(definition);
871
+ return definitionId === undefined ? undefined : environment.startupValues[definitionId];
796
872
  };
797
873
 
798
- // TLC computes each constant definition the configuration doesn't replace when it starts, and
799
- // leaves one it fails to compute to evaluate where the spec uses it.
800
874
  export const evaluateStartupDefinitions = (definitions: Definition[], environment: Environment) =>
801
875
  definitions.forEach((definition) => {
802
876
  if (definition.kind === "Operator" && definition.params.length > 0) return;
803
877
  const name = definition.name;
804
878
  if (environment.constants.has(name) || environment.substitutions.has(name)) return;
805
- if (!isConstantLevel(definition, environment)) return;
806
- const id = environment.facts.ids.get(definition);
807
- 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;
808
882
  const context = { environment, scope: undefined, state: undefined, next: undefined };
809
883
  try {
810
884
  const value = environment.runtime.evaluateAtStartup(() =>
811
885
  toStartupValue(definition, compileDefinitionBody(definition, environment)(context)),
812
886
  );
813
887
  markNormalized(value);
814
- environment.startupValues[id] = value;
888
+ environment.startupValues[definitionId] = value;
815
889
  } catch (error) {
816
890
  // TLC swallows whatever the definition throws, a stack overflow included.
817
891
  if (!(error instanceof TlaEvaluationError) && !isStackOverflow(error)) throw error;
818
892
  }
819
893
  });
820
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
+
821
908
  const forceThunk = (thunk: Thunk, context: Context) => {
822
- const isSameState = thunk.state === context.state && thunk.next === context.next;
823
- if (thunk.cache !== undefined && (isSameState || thunk.isReleased)) return thunk.cache;
824
- const value = evaluate(thunk.expression, withScope(context, thunk.scope));
825
- if (isSameState && (!thunk.isStreamed || isSettledValue(value))) thunk.cache = value;
826
- // A value a thunk cached with no state read no variable, so it holds in every state. Releasing
827
- // its scope frees the evaluations the scope's bindings cached, which a long script keeps alive.
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
+ }
828
928
  if (thunk.cache !== undefined && thunk.state === undefined && thunk.next === undefined) {
829
929
  thunk.scope = undefined;
830
930
  thunk.isReleased = true;
@@ -832,7 +932,7 @@ const forceThunk = (thunk: Thunk, context: Context) => {
832
932
  return value;
833
933
  };
834
934
 
835
- const getDefinitionClosure = (definition: Definition & { kind: "Operator" }): Closure => ({
935
+ export const getDefinitionClosure = (definition: Definition & { kind: "Operator" }): Closure => ({
836
936
  kind: "Closure",
837
937
  name: definition.name,
838
938
  params: definition.params,
@@ -896,6 +996,12 @@ const evaluateOperatorArgument = (expression: Expression, context: Context): Ope
896
996
  };
897
997
 
898
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
+ }
899
1005
  if (operator.kind === "Builtin") return operator.evaluate(args, context);
900
1006
  if (operator.kind === "Operator") return operator.call(args);
901
1007
  const scope = operator.params.reduce<Scope | undefined>(
@@ -913,11 +1019,6 @@ const toOperatorValue = (operator: Operator, context: Context): OperatorValue =>
913
1019
  name: operator.name,
914
1020
  arity: getArity(operator),
915
1021
  call: (args) => callOperatorWithValues(operator, args, context),
916
- literalBody:
917
- operator.kind === "Closure" &&
918
- (operator.body.kind === "Number" || operator.body.kind === "String")
919
- ? operator.body.value
920
- : undefined,
921
1022
  };
922
1023
 
923
1024
  const isOperatorArgument = (expression: Expression, context: Context) => {
@@ -927,6 +1028,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
927
1028
  return operator !== undefined && getArity(operator) > 0;
928
1029
  };
929
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.
930
1032
  const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
931
1033
  args.map((arg) =>
932
1034
  isOperatorArgument(arg, context)
@@ -969,9 +1071,17 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
969
1071
  const isLiteral =
970
1072
  argument.kind === "String" || (argument.kind === "Number" && isTlcInteger(argument.value));
971
1073
  if (isLiteral) {
972
- const binding: Binding = { kind: "Value", value: argument.value };
1074
+ const binding: Binding = { kind: "Value", value: argument.value, argument };
973
1075
  return () => binding;
974
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
+ }
975
1085
  if (argument.kind === "Identifier") {
976
1086
  const global = isLocallyResolved(argument)
977
1087
  ? undefined
@@ -980,7 +1090,7 @@ const compileArgumentBinder = (argument: Expression, environment: Environment):
980
1090
  const binding: Binding = { kind: "Value", value: global.value };
981
1091
  return () => binding;
982
1092
  }
983
- if (global === undefined) {
1093
+ if (global === undefined && !environment.callStack) {
984
1094
  return (context) => {
985
1095
  const binding = lookupScope(context.scope, argument.name);
986
1096
  return binding?.kind === "Value" || binding?.kind === "Thunk"
@@ -1028,14 +1138,11 @@ const callOperator = (
1028
1138
  return operator.evaluate(evaluateBuiltinArguments(args, context), context);
1029
1139
  };
1030
1140
 
1031
- // The LET definitions that a reference evaluates again, and those that cache only a settled value.
1032
1141
  interface ReevaluatedDefinitions {
1033
1142
  impure: ReadonlySet<Definition>;
1034
1143
  streamed: ReadonlySet<Definition>;
1035
1144
  }
1036
1145
 
1037
- // A LET's function definition has one function constructor, as in SANY, so its code compiles once
1038
- // however often the LET is evaluated.
1039
1146
  const letFunctionConstructions = new WeakMap<FunctionDefinition, Expression>();
1040
1147
 
1041
1148
  const getLetFunctionConstruction = (definition: FunctionDefinition): Expression => {
@@ -1056,49 +1163,65 @@ export const bindDefinitions = (
1056
1163
  definitions: Definition[],
1057
1164
  context: Context,
1058
1165
  reevaluated?: ReevaluatedDefinitions,
1059
- ): Scope | undefined =>
1060
- definitions.reduce<Scope | undefined>((scope, definition) => {
1061
- const node: Scope = {
1062
- name: definition.name,
1063
- binding: { kind: "Value", value: false },
1064
- parent: scope,
1065
- };
1066
- if (definition.kind === "Function") {
1067
- node.binding = {
1068
- kind: "Thunk",
1069
- expression: getLetFunctionConstruction(definition),
1070
- scope: node,
1071
- state: context.state,
1072
- next: context.next,
1073
- cache: undefined,
1074
- isStreamed: false,
1075
- };
1076
- return node;
1077
- }
1078
- if (definition.params.length > 0 || reevaluated?.impure.has(definition)) {
1079
- node.binding = {
1080
- kind: "Operator",
1081
- operator: {
1082
- kind: "Closure",
1083
- name: definition.name,
1084
- params: definition.params,
1085
- body: definition.body,
1086
- scope: node,
1087
- },
1088
- };
1089
- return node;
1090
- }
1091
- node.binding = {
1092
- kind: "Thunk",
1093
- expression: definition.body,
1094
- scope: node,
1095
- state: context.state,
1096
- next: context.next,
1097
- cache: undefined,
1098
- isStreamed: reevaluated?.streamed.has(definition) ?? false,
1099
- };
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;
1100
1174
  return node;
1101
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
+ };
1102
1225
 
1103
1226
  const evaluateLocalIdentifier = (name: string, expression: Expression, context: Context): Value => {
1104
1227
  const binding = lookupScope(context.scope, name);
@@ -1120,19 +1243,22 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
1120
1243
  if (global?.kind === "Definition") {
1121
1244
  return getDefinitionEvaluator(global.definition, context.environment)(context);
1122
1245
  }
1123
- const builtin = context.environment.builtins.get(name);
1246
+ const builtin = context.environment.builtins.get(
1247
+ context.environment.substitutions.get(name) ?? name,
1248
+ );
1124
1249
  if (builtin?.arity === 0) return builtin.evaluate([], context);
1125
- 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
+ );
1126
1253
  };
1127
1254
 
1128
- // TLC's next-state generator does not bind LET definitions to values, so each reference to one
1129
- // evaluates it again: one that calls an impure builtin repeats its effects, and a set one builds
1130
- // with UNION or \cup starts out uncached.
1131
1255
  export const getReevaluatedDefinitions = (
1132
1256
  definitions: Definition[],
1133
1257
  environment: Environment,
1134
1258
  ): ReevaluatedDefinitions => ({
1135
- impure: new Set(definitions.filter((definition) => isImpureDefinition(definition, environment))),
1259
+ impure: new Set(
1260
+ definitions.filter((definition) => isImpureDefinition(definition, environment, "varying")),
1261
+ ),
1136
1262
  streamed: new Set(
1137
1263
  definitions.filter((definition) => isImpureDefinition(definition, environment, "streamed")),
1138
1264
  ),
@@ -1143,23 +1269,39 @@ export const isImpure = (environment: Environment) =>
1143
1269
  isImpureDefinition(definition, environment),
1144
1270
  );
1145
1271
 
1146
- // Whether evaluating a definition again can show, such as by printing twice.
1147
1272
  export const hasRepeatedEffects = (environment: Environment) =>
1148
1273
  [...environment.facts.ids.keys()].some((definition) =>
1149
1274
  isImpureDefinition(definition, environment, "repeated"),
1150
1275
  );
1151
1276
 
1152
- // A set filter TLC evaluates lazily, with how to rebuild it so that its predicate runs in another
1153
- // environment.
1154
1277
  interface RebindableFilteredSet extends FilteredSetValue {
1155
1278
  rebind: (environment: Environment) => Value;
1156
1279
  }
1157
1280
 
1158
- const isRebindableFilteredSet = (value: Value): value is RebindableFilteredSet =>
1159
- 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
+ };
1160
1304
 
1161
- // TLC's CallStackTool rebinds the lazy values its evaluations return, so their later evaluation
1162
- // records its call stack too.
1163
1305
  const traceEvaluator =
1164
1306
  (
1165
1307
  expression: Expression,
@@ -1177,13 +1319,17 @@ const traceEvaluator =
1177
1319
  setTrace.callStack = callStack;
1178
1320
  try {
1179
1321
  const computed = evaluator(context);
1180
- const value = isRebindableFilteredSet(computed) ? computed.rebind(environment) : computed;
1322
+ const value = isRebindable(computed) ? computed.rebind(environment) : computed;
1181
1323
  callStack.values.set(expression, value);
1182
1324
  if (typeof value === "object" && value.kind !== "FilteredSet" && isSourced(expression)) {
1183
1325
  callStack.sources.set(value, expression);
1184
1326
  }
1185
1327
  return value;
1186
1328
  } catch (error) {
1329
+ if (error instanceof TlaSetBoundError && !callStack.isFrozen) {
1330
+ callStack.expressions.length = 0;
1331
+ callStack.isFrozen = true;
1332
+ }
1187
1333
  const failed = error instanceof Error ? callStack.failures.get(error) : undefined;
1188
1334
  if (error instanceof Error) callStack.failures.set(error, expression);
1189
1335
  const receiver = getReceiver(expression, callStack.values);
@@ -1211,20 +1357,15 @@ const traceEvaluator =
1211
1357
  }
1212
1358
  };
1213
1359
 
1214
- // A method of a value with a source raises a FingerprintException, which each value with a source
1215
- // whose method called it heads in turn. CallStack#freeze adds their sources to the stack, outermost
1216
- // first. The values are those whose methods failed, outermost first.
1217
1360
  export const freezeCallStack = (
1218
1361
  callStack: CallStack,
1219
1362
  values: (Value | undefined)[],
1220
1363
  error: unknown,
1221
1364
  ) => {
1222
- // A set that streams its elements enumerates itself too, so it can appear twice.
1223
1365
  const sources = [...new Set(values)].flatMap((item) => {
1224
1366
  const source = typeof item === "object" ? callStack.sources.get(item) : undefined;
1225
1367
  return source ? [source] : [];
1226
1368
  });
1227
- // A value with a source raises a FingerprintException even when the stack is frozen already.
1228
1369
  if (sources.length > 0 && error instanceof TlaEvaluationError) {
1229
1370
  if (!callStack.isFrozen) callStack.expressions.push(...sources);
1230
1371
  const inner = callStack.fingerprint;
@@ -1236,8 +1377,6 @@ export const freezeCallStack = (
1236
1377
  callStack.isFrozen = true;
1237
1378
  };
1238
1379
 
1239
- // A FingerprintException that a method of a value with a source raises, or that passes through one,
1240
- // takes the value's source as its new head.
1241
1380
  const headFingerprint = (callStack: CallStack, source: Expression, error: unknown) => {
1242
1381
  if (!(error instanceof TlaEvaluationError)) return;
1243
1382
  if (!callStack.isFrozen) callStack.expressions.push(source);
@@ -1249,8 +1388,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
1249
1388
  };
1250
1389
  };
1251
1390
 
1252
- // A copy of the environment that records the call stack of each evaluation, with evaluators of its
1253
- // own since the environment's evaluators record nothing.
1254
1391
  export const createTracingEnvironment = (environment: Environment): Environment => ({
1255
1392
  ...environment,
1256
1393
  evaluators: new WeakMap(),
@@ -1265,20 +1402,107 @@ export const createTracingEnvironment = (environment: Environment): Environment
1265
1402
  },
1266
1403
  });
1267
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
+
1268
1488
  export const getEvaluator = (expression: Expression, environment: Environment): Evaluator => {
1269
1489
  const cached = environment.evaluators.get(expression);
1270
1490
  if (cached) return cached;
1271
1491
  const compiled = compile(expression, environment);
1272
1492
  const callStack = environment.callStack;
1273
- const evaluator = callStack
1493
+ const frames = callStack && substitutionFrames.get(expression);
1494
+ const traced = callStack
1274
1495
  ? traceEvaluator(expression, compiled, environment, callStack)
1275
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;
1276
1500
  environment.evaluators.set(expression, evaluator);
1277
1501
  return evaluator;
1278
1502
  };
1279
1503
 
1280
1504
  export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
1281
- if (environment.callStack) return getEvaluator(expression, environment);
1505
+ if (environment.callStack || environment.coverage) return getEvaluator(expression, environment);
1282
1506
  const compiled = environment.entryEvaluators.get(expression);
1283
1507
  if (compiled) return compiled;
1284
1508
  const evaluator =
@@ -1309,12 +1533,9 @@ const compileIdentifier = (
1309
1533
  return () => value;
1310
1534
  }
1311
1535
  if (global?.kind === "Definition") {
1312
- // The body compiles when the reference is first evaluated, as a recursive definition's body
1313
- // refers back to it.
1314
1536
  const definition = global.definition;
1315
- const compiled = { reference: undefined as Evaluator | undefined };
1316
- return (context) =>
1317
- (compiled.reference ??= getDefinitionEvaluator(definition, environment))(context);
1537
+ let compiled: Evaluator | undefined;
1538
+ return (context) => (compiled ??= getDefinitionEvaluator(definition, environment))(context);
1318
1539
  }
1319
1540
  return (context) => evaluateLocalIdentifier(name, expression, context);
1320
1541
  };
@@ -1394,11 +1615,10 @@ const compileClosureCall = (
1394
1615
  environment: Environment,
1395
1616
  ): Evaluator => {
1396
1617
  const bindArguments = compileArgumentScope(closure, args, environment);
1397
- // The body compiles when the call is first evaluated, as a recursive operator's body calls it.
1398
- const compiled = { body: undefined as Evaluator | undefined };
1618
+ let body: Evaluator | undefined;
1399
1619
  return (context) => {
1400
- compiled.body ??= getEntryEvaluator(closure.body, environment);
1401
- return compiled.body({
1620
+ body ??= getEntryEvaluator(closure.body, environment);
1621
+ return body({
1402
1622
  environment,
1403
1623
  scope: bindArguments(context),
1404
1624
  state: context.state,
@@ -1408,6 +1628,26 @@ const compileClosureCall = (
1408
1628
  };
1409
1629
  };
1410
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
+
1411
1651
  const compileApply = (
1412
1652
  expression: Expression & { kind: "Apply" },
1413
1653
  environment: Environment,
@@ -1417,12 +1657,24 @@ const compileApply = (
1417
1657
  const left = getEvaluator(args[0], environment);
1418
1658
  const right = getEvaluator(args[1], environment);
1419
1659
  return (context) =>
1420
- !expectBoolean(left(context), "the left side of =>") ||
1421
- 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);
1422
1666
  }
1423
- 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 === "-+->") {
1424
1673
  return () => {
1425
- 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
+ );
1426
1678
  };
1427
1679
  }
1428
1680
  const global = isLocallyResolved(expression)
@@ -1434,23 +1686,66 @@ const compileApply = (
1434
1686
  const domain = getDomainOperator(expression);
1435
1687
  return (context) => domain(operand(context));
1436
1688
  }
1437
- // TLC sorts the value of a constant TLCEval argument only where no context binds a name.
1438
1689
  if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
1439
- const operand = getEvaluator(args[0], environment);
1440
- if (contextualApplications.has(expression) || isNonconstant(args[0], environment)) {
1441
- return operand;
1442
- }
1443
- return (context) =>
1444
- 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
+ };
1445
1704
  }
1446
- 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
+ ) {
1447
1711
  const left = getEvaluator(args[0], environment);
1448
1712
  const right = getEvaluator(args[1], environment);
1449
- const subset = getSubsetOperator(expression, global);
1450
- 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
+ };
1451
1747
  }
1452
1748
  if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
1453
- // TLC refuses action composition unless a Java property enables its incomplete implementation.
1454
1749
  if (expression.operator === "\\cdot" && args.length === 2) {
1455
1750
  return () => {
1456
1751
  throw new TlaEvaluationError(
@@ -1479,9 +1774,20 @@ const compileQuantifier = (
1479
1774
  environment: Environment,
1480
1775
  ): Evaluator => {
1481
1776
  const isForall = expression.kind === "Forall";
1482
- const description = isForall ? "the body of \\A" : "the body of \\E";
1483
1777
  const body = getEvaluator(expression.body, environment);
1484
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
+ }
1485
1791
  if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
1486
1792
  const name = bound.pattern.name;
1487
1793
  const set = getEvaluator(bound.set, environment);
@@ -1489,9 +1795,9 @@ const compileQuantifier = (
1489
1795
  const isFound = someElement(
1490
1796
  getQuantifierElements(set(context), bound.set, environment.runtime.version),
1491
1797
  (element) =>
1492
- expectBoolean(
1798
+ expectBooleanBody(
1493
1799
  body(withScope(context, bindValue(context.scope, name, element))),
1494
- description,
1800
+ expression,
1495
1801
  ) !== isForall,
1496
1802
  );
1497
1803
  return isFound ? !isForall : isForall;
@@ -1500,14 +1806,17 @@ const compileQuantifier = (
1500
1806
  const bounds = expression.bounds;
1501
1807
  if (bounds.every((item) => item.pattern.kind === "Name")) {
1502
1808
  const names = bounds.map((item) => (item.pattern.kind === "Name" ? item.pattern.name : ""));
1503
- const sets = bounds.map((item) => getEvaluator(item.set, environment));
1504
1809
  return (context) => {
1505
- const lists = sets.map((set, index) =>
1506
- 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
+ ),
1507
1816
  );
1508
1817
  const visit = (index: number, scope: Scope | undefined): boolean => {
1509
1818
  if (index < 0) {
1510
- return expectBoolean(body(withScope(context, scope)), description) !== isForall;
1819
+ return expectBooleanBody(body(withScope(context, scope)), expression) !== isForall;
1511
1820
  }
1512
1821
  return someElement(lists[index], (element) =>
1513
1822
  visit(index - 1, bindValue(scope, names[index], element)),
@@ -1520,7 +1829,7 @@ const compileQuantifier = (
1520
1829
  const isFound = forEachBinding(
1521
1830
  bounds,
1522
1831
  context,
1523
- (scope) => expectBoolean(body(withScope(context, scope)), description) !== isForall,
1832
+ (scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
1524
1833
  );
1525
1834
  return isFound ? !isForall : isForall;
1526
1835
  };
@@ -1539,8 +1848,6 @@ const getBoundValue = (pattern: BoundPattern, scope: Scope | undefined) => {
1539
1848
  return binding?.kind === "Value" ? binding.value : undefined;
1540
1849
  };
1541
1850
 
1542
- // TLC keeps a function constructor lazy when it is the function of an application, or the base of
1543
- // an EXCEPT that is, so it evaluates the body only at the arguments it is applied to.
1544
1851
  const keptLazyExpressions = new WeakSet<Expression>();
1545
1852
 
1546
1853
  export const keepLazy = (expression: Expression) => {
@@ -1549,8 +1856,6 @@ export const keepLazy = (expression: Expression) => {
1549
1856
  }
1550
1857
  };
1551
1858
 
1552
- // The names an expression may look up in its scope, or undefined when a subexpression selector may
1553
- // look up others.
1554
1859
  const scopeNames = new WeakMap<Expression, string[] | undefined>();
1555
1860
 
1556
1861
  const getScopeNames = (expression: Expression) => {
@@ -1558,8 +1863,8 @@ const getScopeNames = (expression: Expression) => {
1558
1863
  const names = new Set<string>();
1559
1864
  const visit = (node: Expression): boolean => {
1560
1865
  if (node.kind === "Subexpression") return false;
1561
- if (node.kind === "Identifier") names.add(node.name);
1562
- if (node.kind === "Apply" || node.kind === "OperatorReference") names.add(node.operator);
1866
+ const name = getReferencedName(node);
1867
+ if (name !== undefined) names.add(name);
1563
1868
  if (node.kind === "ExceptAt") names.add(EXCEPT_AT);
1564
1869
  return getChildren(node).every(visit);
1565
1870
  };
@@ -1568,9 +1873,6 @@ const getScopeNames = (expression: Expression) => {
1568
1873
  return result;
1569
1874
  };
1570
1875
 
1571
- // The bindings of a scope that names look up, so that a lazy function keeps only those alive and
1572
- // not the values its other bindings cached. An unnamed node ends the chain, since a TLCEval in the
1573
- // body sorts its value only where no context binds a name.
1574
1876
  const trimScope = (scope: Scope | undefined, names: string[] | undefined) =>
1575
1877
  names === undefined || scope === undefined
1576
1878
  ? scope
@@ -1582,32 +1884,41 @@ const trimScope = (scope: Scope | undefined, names: string[] | undefined) =>
1582
1884
  { name: "", binding: { kind: "Value", value: false }, parent: undefined },
1583
1885
  );
1584
1886
 
1585
- const compileFunctionConstruction = (
1887
+ export const isKeptLazy = (expression: Expression) => keptLazyExpressions.has(expression);
1888
+
1889
+ export const getFunctionBuilder = (
1586
1890
  expression: Expression & { kind: "FunctionConstruction" },
1587
1891
  environment: Environment,
1588
- ): Evaluator => {
1589
- const isKeptLazy = keptLazyExpressions.has(expression);
1892
+ ) => {
1893
+ const isKeptLazyExpression = isKeptLazy(expression);
1590
1894
  const body = getEvaluator(expression.body, environment);
1591
1895
  const bounds = expression.bounds;
1592
1896
  const bound = bounds[0];
1593
1897
  const isSingleName = bounds.length === 1 && bound.pattern.kind === "Name";
1594
- const set = getEvaluator(bound.set, environment);
1595
1898
  const construct = (domain: Value, context: Context) => {
1596
1899
  if (isSingleName && bound.pattern.kind === "Name") {
1597
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
+ }
1598
1909
  const keys = getFunctionDomain(domain);
1599
- const functionValue = createSortedFunction(
1600
- keys,
1601
- keys.map((key) => body(withScope(context, bindValue(context.scope, name, key)))),
1602
- );
1603
- // FcnLambdaValue#toFcnRcd builds a FcnRcdValue over an interval or an enumerated set.
1604
- 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);
1605
1914
  }
1606
1915
  const pairs: [Value, Value][] = [];
1607
- const sets = bounds.map((item) =>
1916
+ const sets = mapBoundSets(bounds, (set, index) =>
1608
1917
  getNormalizedElements(
1609
- evaluate(item.set, context),
1610
- item.set,
1918
+ bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
1919
+ ? domain.factors[index]
1920
+ : domain,
1921
+ set,
1611
1922
  context.environment.runtime.version,
1612
1923
  ),
1613
1924
  );
@@ -1622,15 +1933,26 @@ const compileFunctionConstruction = (
1622
1933
  return createFunction(pairs);
1623
1934
  };
1624
1935
  const template = getLazyFunctionTemplate(bounds, expression.body);
1936
+ const boundTupleLengths = getBoundTupleLengths(bounds);
1625
1937
  const bodyNames = getScopeNames(expression.body);
1938
+ const coverage = environment.coverage;
1626
1939
  const createLazy = (domain: Value, context: Context) => {
1627
1940
  const scope = trimScope(context.scope, bodyNames);
1628
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;
1629
1945
  const functionValue = keepLambda({
1630
1946
  value: createLazyFunction(
1631
1947
  domain,
1632
- (argument) => body(withScope(lambdaContext, bindArgument(bounds, scope, argument))),
1948
+ coverage
1949
+ ? (argument) =>
1950
+ coverage.current === -1
1951
+ ? compute(argument)
1952
+ : runAtCoverageNode(coverage, node, () => compute(argument))
1953
+ : compute,
1633
1954
  getLazyFunctionSource(template, bounds, domain),
1955
+ boundTupleLengths,
1634
1956
  ),
1635
1957
  bounds,
1636
1958
  body: expression.body,
@@ -1639,15 +1961,22 @@ const compileFunctionConstruction = (
1639
1961
  return bounds.length === 1 ? markLambdaFunction(functionValue) : functionValue;
1640
1962
  };
1641
1963
  const callStack = environment.callStack;
1642
- return (context) => {
1643
- const domain = isSingleName ? set(context) : getBoundsDomain(bounds, context);
1644
- 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
+ ) {
1645
1971
  return createLazy(domain, context);
1646
1972
  }
1647
- // TLC builds a function over a domain other than a set enumeration or an interval lazily, so
1648
- // its body fails only where TLC forces it, as the replay does. Building it at once is faster
1649
- // otherwise.
1650
- 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) {
1651
1980
  if (callStack) return createLazy(domain, context);
1652
1981
  try {
1653
1982
  return construct(domain, context);
@@ -1657,7 +1986,6 @@ const compileFunctionConstruction = (
1657
1986
  }
1658
1987
  }
1659
1988
  if (!callStack) return construct(domain, context);
1660
- // TLC builds the function in a method of the FcnLambdaValue that CallStackTool gives a source.
1661
1989
  try {
1662
1990
  return construct(domain, context);
1663
1991
  } catch (error) {
@@ -1665,14 +1993,45 @@ const compileFunctionConstruction = (
1665
1993
  throw error;
1666
1994
  }
1667
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);
1668
2027
  };
1669
2028
 
1670
2029
  const compileExcept = (
1671
2030
  expression: Expression & { kind: "Except" },
1672
2031
  environment: Environment,
1673
2032
  ): Evaluator => {
1674
- const isKeptLazy = keptLazyExpressions.has(expression);
1675
- if (isKeptLazy) keepLazy(expression.function);
2033
+ const isKeptLazyExpression = keptLazyExpressions.has(expression);
2034
+ if (isKeptLazyExpression) keepLazy(expression.function);
1676
2035
  const evaluateFunction = getEvaluator(expression.function, environment);
1677
2036
  const updates = expression.updates.map((update) => ({
1678
2037
  path: update.path.map((step): CompiledStep =>
@@ -1705,19 +2064,18 @@ const compileExcept = (
1705
2064
  current,
1706
2065
  getKey(path[depth], context),
1707
2066
  (previous) => update(previous, path, depth + 1, context, value),
1708
- isKeptLazy && depth === 0,
2067
+ isKeptLazyExpression && depth === 0,
1709
2068
  );
1710
2069
  };
1711
2070
  return (context) => {
1712
2071
  let current = evaluateFunction(context);
1713
2072
  for (const item of updates) {
1714
- // TLC leaves the value as it is when an update's path is not in it, and warns.
1715
- const found = { value: false };
2073
+ let isFound = false;
1716
2074
  current = update(current, item.path, 0, context, (inner) => {
1717
- found.value = true;
2075
+ isFound = true;
1718
2076
  return item.value(inner);
1719
2077
  });
1720
- if (!found.value) {
2078
+ if (!isFound) {
1721
2079
  context.environment.runtime.warn(
1722
2080
  MESSAGE_CODE.exceptAppliedToUnknownField,
1723
2081
  `The EXCEPT was applied to non-existing fields of the value at\n${describeRange(expression.function)}`,
@@ -1728,6 +2086,119 @@ const compileExcept = (
1728
2086
  };
1729
2087
  };
1730
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
+
1731
2202
  const compileSetComprehension = (
1732
2203
  expression: Expression & { kind: "SetFilter" | "SetMap" | "Choose" },
1733
2204
  environment: Environment,
@@ -1735,48 +2206,37 @@ const compileSetComprehension = (
1735
2206
  if (expression.kind === "SetFilter") {
1736
2207
  const predicate = getEvaluator(expression.predicate, environment);
1737
2208
  const set = getEvaluator(expression.bound.set, environment);
2209
+ const filterLazily = getLazyFilter(expression, environment);
1738
2210
  const pattern = expression.bound.pattern;
1739
- const range = expression.predicate.location.range;
1740
- const source = range && {
1741
- names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
1742
- predicate: formatRange(range),
1743
- };
1744
- const createTest = (evaluator: Evaluator, context: Context) => (element: Value) =>
1745
- expectBoolean(
1746
- evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
1747
- "a set filter predicate",
1748
- );
1749
- const createFiltered = (
1750
- base: Value,
1751
- context: Context,
1752
- evaluator: Evaluator,
1753
- ): RebindableFilteredSet => ({
1754
- kind: "FilteredSet",
1755
- base,
1756
- test: createTest(evaluator, context),
1757
- source,
1758
- rebind: (tracing) =>
1759
- createFiltered(
1760
- base,
1761
- { ...context, environment: tracing },
1762
- getEvaluator(expression.predicate, tracing),
1763
- ),
1764
- });
2211
+ const coverage = environment.coverage;
2212
+ const isUniform = isUniformPredicate(expression, environment);
1765
2213
  return (context) => {
1766
2214
  const base = set(context);
1767
- // TLC filters any value it can't enumerate lazily, and fails only when it uses the result.
1768
- if (!isReducibleSet(base)) return createFiltered(base, context, predicate);
1769
- 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);
1770
2227
  };
1771
2228
  }
1772
2229
  if (expression.kind === "SetMap") {
1773
2230
  const mapped = getEvaluator(expression.expression, environment);
2231
+ const coverage = environment.coverage;
1774
2232
  return (context) => {
1775
2233
  const elements: Value[] = [];
1776
- forEachBinding(expression.bounds, context, (scope) => {
1777
- elements.push(mapped(withScope(context, scope)));
2234
+ const add = (scope: Scope | undefined) => {
2235
+ addBoundedElement(elements, mapped(withScope(context, scope)));
1778
2236
  return false;
1779
- });
2237
+ };
2238
+ if (coverage) forEachChargedBinding(expression.bounds, context, coverage, add);
2239
+ else forEachBinding(expression.bounds, context, add);
1780
2240
  return createEnumeratedSet(elements);
1781
2241
  };
1782
2242
  }
@@ -1784,37 +2244,40 @@ const compileSetComprehension = (
1784
2244
  if (!set) {
1785
2245
  return () => {
1786
2246
  throw new TlaEvaluationError(
1787
- `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)}`,
1788
2248
  );
1789
2249
  };
1790
2250
  }
1791
2251
  const body = getEvaluator(expression.body, environment);
1792
2252
  const evaluateSet = getEvaluator(set, environment);
2253
+ const coverage = environment.coverage;
1793
2254
  return (context) => {
1794
2255
  const base = evaluateSet(context);
1795
- if (!isSetValue(base) || isOverriddenSet(base)) {
1796
- throw new TlaEvaluationError(
1797
- `Attempted to compute the value of an expression of\nform CHOOSE x \\in S: P, but S was not enumerable.\n${describeRange(expression)}`,
1798
- );
1799
- }
1800
- const chosen = { value: undefined as Value | undefined };
1801
- 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;
1802
2260
  someElement(elements, (element) => {
1803
- const scope = bindPattern(context.scope, expression.pattern, element);
1804
- if (!expectBoolean(body(withScope(context, scope)), "the body of CHOOSE")) return false;
1805
- 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);
1806
2273
  return true;
1807
2274
  });
1808
- if (chosen.value === undefined) {
1809
- throw new TlaEvaluationError(
1810
- `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)}`,
1811
- );
1812
- }
1813
- return chosen.value;
2275
+ if (chosen !== undefined) return chosen;
2276
+ enumerator?.next();
2277
+ throw createNoChoiceError(expression);
1814
2278
  };
1815
2279
  };
1816
2280
 
1817
- // TLC orders a record's fields by name.
1818
2281
  export const getSortedFields = (fields: RecordField[]) =>
1819
2282
  [...fields].sort((left, right) => compareValues(left.name, right.name));
1820
2283
 
@@ -1823,20 +2286,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
1823
2286
 
1824
2287
  const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
1825
2288
  const fields = getSortedFields(recordFields);
1826
- const hasDuplicates = hasDuplicateFields(fields);
1827
- const values = fields.map((field) => getEvaluator(field.value, environment));
1828
- if (hasDuplicates) {
2289
+ const values = recordFields.map((field) => getEvaluator(field.value, environment));
2290
+ if (hasDuplicateFields(fields)) {
1829
2291
  return (context) =>
1830
2292
  createRecord(
1831
- fields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2293
+ recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
1832
2294
  );
1833
2295
  }
1834
2296
  const names = fields.map((field) => field.name);
1835
2297
  const writtenNames = recordFields.map((field) => field.name);
1836
2298
  if (writtenNames.some((name, index) => name !== names[index])) {
2299
+ const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
1837
2300
  return (context) =>
1838
2301
  createWrittenRecord(
1839
2302
  names,
2303
+ writtenIndexes,
1840
2304
  values.map((value) => value(context)),
1841
2305
  writtenNames,
1842
2306
  );
@@ -1886,48 +2350,38 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1886
2350
  };
1887
2351
  case "And": {
1888
2352
  const operands = expression.operands.map(getChildEvaluator);
1889
- return (context) => {
1890
- for (let index = 0; index < operands.length; index++) {
1891
- const value = operands[index](context);
1892
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
1893
- if (!value) return false;
1894
- }
1895
- return true;
1896
- };
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
+ );
1897
2364
  }
1898
2365
  case "Or": {
1899
2366
  const operands = expression.operands.map(getChildEvaluator);
1900
- return (context) => {
1901
- for (let index = 0; index < operands.length; index++) {
1902
- const value = operands[index](context);
1903
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
1904
- if (value) return true;
1905
- }
1906
- return false;
1907
- };
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
+ );
1908
2378
  }
1909
2379
  case "Prime": {
1910
2380
  const inner = getChildEvaluator(expression.expression);
1911
- return (context) => {
1912
- if (!context.next) throw createPrimeOutsideActionError(expression);
1913
- return inner({
1914
- environment: context.environment,
1915
- scope: context.scope,
1916
- state: context.next,
1917
- next: undefined,
1918
- isKeepLazy: context.isKeepLazy,
1919
- });
1920
- };
1921
- }
1922
- case "Unchanged": {
1923
- const primed = getChildEvaluator({
1924
- kind: "Prime",
1925
- expression: expression.expression,
1926
- location: expression.location,
1927
- });
1928
- const current = getChildEvaluator(expression.expression);
1929
- return (context) => valuesEqual(primed(context), current(context));
2381
+ return (context) => inner(toNextContext(context));
1930
2382
  }
2383
+ case "Unchanged":
2384
+ return compileUnchanged(getChildEvaluator(expression.expression));
1931
2385
  case "If": {
1932
2386
  const condition = getChildEvaluator(expression.condition);
1933
2387
  const consequent = getChildEvaluator(expression.consequent);
@@ -1971,8 +2425,15 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1971
2425
  return compileQuantifier(expression, environment);
1972
2426
  case "UnboundedQuantifier":
1973
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
+ }
1974
2435
  throw new TlaEvaluationError(
1975
- `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)}`,
1976
2437
  );
1977
2438
  };
1978
2439
  case "Choose":
@@ -1999,8 +2460,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
1999
2460
  case "RecordSet": {
2000
2461
  const fields = getSortedFields(expression.fields);
2001
2462
  const names = fields.map((field) => field.name);
2002
- const sets = fields.map((field) => getChildEvaluator(field.value));
2003
- 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
+ };
2004
2476
  }
2005
2477
  case "Except":
2006
2478
  return compileExcept(expression, environment);
@@ -2048,16 +2520,18 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2048
2520
  case "BoxAction":
2049
2521
  case "AngleAction": {
2050
2522
  const action = getChildEvaluator(expression.action);
2051
- const unchanged = getChildEvaluator({
2052
- kind: "Unchanged",
2053
- expression: expression.subscript,
2054
- location: expression.location,
2055
- });
2523
+ const unchanged = compileUnchanged(getChildEvaluator(expression.subscript));
2056
2524
  const isBox = expression.kind === "BoxAction";
2057
- return (context) =>
2058
- isBox
2059
- ? expectBoolean(action(context), "an action") || unchanged(context)
2060
- : 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
+ };
2061
2535
  }
2062
2536
  case "Enabled": {
2063
2537
  const action = expression.expression;
@@ -2065,6 +2539,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2065
2539
  }
2066
2540
  case "Label":
2067
2541
  return getChildEvaluator(expression.body);
2542
+ case "Selection":
2543
+ return getChildEvaluator(expression.expression);
2068
2544
  case "Subexpression":
2069
2545
  return () => {
2070
2546
  throw new TlaEvaluationError(
@@ -2076,9 +2552,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2076
2552
  case "WeakFairness":
2077
2553
  case "StrongFairness":
2078
2554
  return () => {
2079
- throw new TlaEvaluationError(
2080
- `TLC cannot evaluate a temporal formula in a state at ${describeLocation(expression)}`,
2081
- );
2555
+ throw createTemporalFormulaError(TEMPORAL_FORMS[expression.kind], expression);
2082
2556
  };
2083
2557
  }
2084
2558
  };