tla-ts 0.0.4 → 0.0.5-dev.552d313

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 (378) hide show
  1. package/README.md +38 -127
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +46 -12
  8. package/dist/index.d.ts +46 -12
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +76 -92
  23. package/dist/transfer.js +76 -92
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +21 -12
  27. package/src/ast.ts +2 -2
  28. package/src/bags.ts +22 -23
  29. package/src/builtins.ts +16 -8
  30. package/src/check.ts +131 -1153
  31. package/src/{cli-options.ts → cli/options.ts} +54 -9
  32. package/src/cli/run.ts +63 -0
  33. package/src/cli/shared.ts +106 -0
  34. package/src/cli/tlapm.ts +374 -0
  35. package/src/{run-cli.ts → cli/tlc.ts} +115 -721
  36. package/src/cli/xml-exporter.ts +221 -0
  37. package/src/cli.ts +1 -1
  38. package/src/codegen.ts +43 -22
  39. package/src/config.ts +5 -5
  40. package/src/dependencies.ts +4 -6
  41. package/src/environment.ts +55 -60
  42. package/src/errors.ts +97 -35
  43. package/src/evaluate.ts +361 -181
  44. package/src/exit-codes.ts +1 -1
  45. package/src/fingerprints.ts +3 -3
  46. package/src/index.ts +10 -0
  47. package/src/instances.ts +56 -46
  48. package/src/java-overrides.ts +79 -41
  49. package/src/json.ts +31 -36
  50. package/src/levels.ts +10 -13
  51. package/src/{live-check.ts → liveness-checker.ts} +207 -141
  52. package/src/liveness.ts +38 -34
  53. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  54. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  55. package/src/obligations/equality.ts +260 -0
  56. package/src/obligations/expression.ts +618 -0
  57. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  58. package/src/obligations/generate.ts +457 -0
  59. package/src/{obligations.ts → obligations/index.ts} +46 -32
  60. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  61. package/src/obligations/module.ts +445 -0
  62. package/src/obligations/normalize.ts +554 -0
  63. package/src/obligations/operators.ts +176 -0
  64. package/src/obligations/pragma.ts +195 -0
  65. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  66. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  67. package/src/obligations/regroup.ts +100 -0
  68. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  69. package/src/{obligation-source.ts → obligations/source.ts} +172 -216
  70. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  71. package/src/obligations/substitution.ts +261 -0
  72. package/src/obligations/temporal.ts +321 -0
  73. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  74. package/src/parallel-worker.ts +39 -51
  75. package/src/parallel.ts +39 -66
  76. package/src/parser.ts +67 -74
  77. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  78. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  79. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  80. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  81. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  82. package/src/prover/decide-pool.ts +95 -0
  83. package/src/prover/deciders.ts +33 -0
  84. package/src/prover/first-order.ts +175 -0
  85. package/src/prover/isabelle/LICENSE +36 -0
  86. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  87. package/src/prover/isabelle/decide.ts +44 -0
  88. package/src/prover/isabelle/encode.ts +445 -0
  89. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  90. package/src/prover/isabelle/isar/method.ts +367 -0
  91. package/src/prover/isabelle/isar/proof.ts +28 -0
  92. package/src/prover/isabelle/isar/statement.ts +57 -0
  93. package/src/prover/isabelle/isar/theory.ts +192 -0
  94. package/src/prover/isabelle/isar/type-check.ts +278 -0
  95. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  96. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  97. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  98. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  99. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  100. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  101. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  102. package/src/prover/isabelle/provers/classical.ts +389 -0
  103. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  104. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  105. package/src/prover/isabelle/pure/consts.ts +32 -0
  106. package/src/prover/isabelle/pure/conv.ts +79 -0
  107. package/src/prover/isabelle/pure/drule.ts +264 -0
  108. package/src/prover/isabelle/pure/envir.ts +331 -0
  109. package/src/prover/isabelle/pure/goal.ts +53 -0
  110. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  111. package/src/prover/isabelle/pure/list.ts +12 -0
  112. package/src/prover/isabelle/pure/logic.ts +330 -0
  113. package/src/prover/isabelle/pure/name.ts +98 -0
  114. package/src/prover/isabelle/pure/net.ts +215 -0
  115. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  116. package/src/prover/isabelle/pure/pattern.ts +631 -0
  117. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  118. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  119. package/src/prover/isabelle/pure/search.ts +68 -0
  120. package/src/prover/isabelle/pure/seq.ts +133 -0
  121. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  122. package/src/prover/isabelle/pure/table.ts +201 -0
  123. package/src/prover/isabelle/pure/tactic.ts +168 -0
  124. package/src/prover/isabelle/pure/tactical.ts +264 -0
  125. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  126. package/src/prover/isabelle/pure/term.ts +688 -0
  127. package/src/prover/isabelle/pure/thm.ts +783 -0
  128. package/src/prover/isabelle/pure/type.ts +121 -0
  129. package/src/prover/isabelle/pure/unify.ts +753 -0
  130. package/src/prover/isabelle/pure/variable.ts +25 -0
  131. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  132. package/src/prover/isabelle/tla/context.ts +74 -0
  133. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  134. package/src/prover/isabelle/tla/logic.ts +215 -0
  135. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  136. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  137. package/src/prover/ocaml.ts +22 -0
  138. package/src/prover/prep/action.ts +508 -0
  139. package/src/prover/prep/enabled-axioms.ts +189 -0
  140. package/src/prover/prep/fingerprint.ts +388 -0
  141. package/src/prover/prep/level-comparison.ts +529 -0
  142. package/src/prover/prep/md5.ts +60 -0
  143. package/src/prover/prep/methods.ts +221 -0
  144. package/src/prover/prep/normalize.ts +309 -0
  145. package/src/prover/prove-worker.ts +22 -0
  146. package/src/prover/prove.ts +492 -0
  147. package/src/prover/ptl/decide.ts +68 -0
  148. package/src/prover/ptl/encode.ts +244 -0
  149. package/src/prover/ptl/sat.ts +151 -0
  150. package/src/prover/ptl/tableau.ts +276 -0
  151. package/src/prover/smt/axioms.ts +209 -0
  152. package/src/prover/smt/context.ts +108 -0
  153. package/src/prover/smt/data.ts +636 -0
  154. package/src/prover/smt/encode.ts +275 -0
  155. package/src/prover/smt/extensionality.ts +65 -0
  156. package/src/prover/smt/flatten.ts +112 -0
  157. package/src/prover/smt/format.ts +154 -0
  158. package/src/prover/smt/instances.ts +181 -0
  159. package/src/prover/smt/rewrite.ts +766 -0
  160. package/src/prover/smt/solver/act-cache.ts +265 -0
  161. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  162. package/src/prover/smt/solver/array.ts +22 -0
  163. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  164. package/src/prover/smt/solver/ast-lt.ts +157 -0
  165. package/src/prover/smt/solver/ast-util.ts +91 -0
  166. package/src/prover/smt/solver/ast.ts +1315 -0
  167. package/src/prover/smt/solver/auf-solver.ts +572 -0
  168. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  169. package/src/prover/smt/solver/cg-table.ts +175 -0
  170. package/src/prover/smt/solver/clause.ts +276 -0
  171. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  172. package/src/prover/smt/solver/context.ts +1292 -0
  173. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  174. package/src/prover/smt/solver/der.ts +224 -0
  175. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  176. package/src/prover/smt/solver/e-matching.ts +659 -0
  177. package/src/prover/smt/solver/enode.ts +259 -0
  178. package/src/prover/smt/solver/expr-ref.ts +21 -0
  179. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  180. package/src/prover/smt/solver/fingerprints.ts +92 -0
  181. package/src/prover/smt/solver/flat-literals.ts +51 -0
  182. package/src/prover/smt/solver/goal.ts +138 -0
  183. package/src/prover/smt/solver/hash.ts +173 -0
  184. package/src/prover/smt/solver/hashtable.ts +166 -0
  185. package/src/prover/smt/solver/internalizer.ts +1381 -0
  186. package/src/prover/smt/solver/lbool.ts +5 -0
  187. package/src/prover/smt/solver/literal.ts +24 -0
  188. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  189. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  190. package/src/prover/smt/solver/lp/containers.ts +296 -0
  191. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  192. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  193. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  194. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  195. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  196. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  197. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  198. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  199. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  200. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  201. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  202. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  203. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  204. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  205. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  206. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  207. package/src/prover/smt/solver/lp/nex.ts +120 -0
  208. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  209. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  210. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  211. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  212. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  213. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  214. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  215. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  216. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  217. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  218. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  219. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  220. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  221. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  222. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  223. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  224. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  225. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  226. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  227. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  228. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  229. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  230. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  231. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  232. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  233. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  234. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  235. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  236. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  237. package/src/prover/smt/solver/model-checker.ts +347 -0
  238. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  239. package/src/prover/smt/solver/model-finder.ts +155 -0
  240. package/src/prover/smt/solver/model-generator.ts +97 -0
  241. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  242. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  243. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  244. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  245. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  246. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  247. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  248. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  249. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  250. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  251. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  252. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +645 -0
  253. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  254. package/src/prover/smt/solver/nnf.ts +469 -0
  255. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  256. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  257. package/src/prover/smt/solver/propagate-values.ts +83 -0
  258. package/src/prover/smt/solver/proto-model.ts +551 -0
  259. package/src/prover/smt/solver/pull-quant.ts +139 -0
  260. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  261. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  262. package/src/prover/smt/solver/qe-lite.ts +381 -0
  263. package/src/prover/smt/solver/qi-queue.ts +362 -0
  264. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  265. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  266. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  267. package/src/prover/smt/solver/random-gen.ts +10 -0
  268. package/src/prover/smt/solver/rational.ts +165 -0
  269. package/src/prover/smt/solver/ref-vector.ts +62 -0
  270. package/src/prover/smt/solver/relevancy.ts +247 -0
  271. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  272. package/src/prover/smt/solver/rewriter.ts +843 -0
  273. package/src/prover/smt/solver/rlimit.ts +79 -0
  274. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  275. package/src/prover/smt/solver/solver.ts +71 -0
  276. package/src/prover/smt/solver/sort.ts +35 -0
  277. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  278. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  279. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  280. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  281. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  282. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  283. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  284. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  285. package/src/prover/smt/solver/theory-lra.ts +56 -0
  286. package/src/prover/smt/solver/var-subst.ts +258 -0
  287. package/src/prover/smt/solver/z3-license.txt +10 -0
  288. package/src/prover/smt/table.ts +170 -0
  289. package/src/prover/tlapm/cache.ts +236 -0
  290. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  291. package/src/prover/tlapm/tlapm.ts +96 -0
  292. package/src/prover/tlaps-module.ts +510 -0
  293. package/src/prover/verdict.ts +13 -0
  294. package/src/prover/zenon/LICENSE +32 -0
  295. package/src/prover/zenon/check/check.ts +105 -0
  296. package/src/prover/zenon/check/definitions.ts +144 -0
  297. package/src/prover/zenon/check/equality.ts +182 -0
  298. package/src/prover/zenon/check/functions.ts +62 -0
  299. package/src/prover/zenon/check/keys.ts +125 -0
  300. package/src/prover/zenon/check/propositional.ts +104 -0
  301. package/src/prover/zenon/check/records.ts +188 -0
  302. package/src/prover/zenon/check/relations.ts +121 -0
  303. package/src/prover/zenon/check/rewrites.ts +224 -0
  304. package/src/prover/zenon/check/sets.ts +302 -0
  305. package/src/prover/zenon/check/terms.ts +127 -0
  306. package/src/prover/zenon/check/tla.ts +126 -0
  307. package/src/prover/zenon/decide.ts +107 -0
  308. package/src/prover/zenon/encode.ts +378 -0
  309. package/src/prover/zenon/eqrel.ts +300 -0
  310. package/src/prover/zenon/equality-rules.ts +435 -0
  311. package/src/prover/zenon/expr.ts +551 -0
  312. package/src/prover/zenon/index-table.ts +350 -0
  313. package/src/prover/zenon/isar-case.ts +513 -0
  314. package/src/prover/zenon/isar.ts +1249 -0
  315. package/src/prover/zenon/limits.ts +15 -0
  316. package/src/prover/zenon/llproof.ts +173 -0
  317. package/src/prover/zenon/mltoll.ts +1566 -0
  318. package/src/prover/zenon/node.ts +297 -0
  319. package/src/prover/zenon/ocaml.ts +169 -0
  320. package/src/prover/zenon/parse.ts +247 -0
  321. package/src/prover/zenon/phrase.ts +191 -0
  322. package/src/prover/zenon/proof.ts +198 -0
  323. package/src/prover/zenon/propositional-rules.ts +387 -0
  324. package/src/prover/zenon/rules.ts +94 -0
  325. package/src/prover/zenon/search.ts +288 -0
  326. package/src/prover/zenon/tla/functions.ts +151 -0
  327. package/src/prover/zenon/tla/llproof.ts +480 -0
  328. package/src/prover/zenon/tla/records.ts +225 -0
  329. package/src/prover/zenon/tla/rewrites.ts +447 -0
  330. package/src/prover/zenon/tla/sets.ts +304 -0
  331. package/src/prover/zenon/tla/terms.ts +162 -0
  332. package/src/prover/zenon/tla/tla.ts +506 -0
  333. package/src/randomization.ts +19 -24
  334. package/src/resolve.ts +15 -22
  335. package/src/runtime.ts +8 -8
  336. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  337. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  338. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  339. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  340. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  341. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  342. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  343. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  344. package/src/{sany-report.ts → sany/report.ts} +16 -17
  345. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  346. package/src/{sany-source.ts → sany/source.ts} +6 -7
  347. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  348. package/src/search.ts +969 -0
  349. package/src/spec-description.ts +26 -20
  350. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  351. package/src/standard-modules.ts +21 -22
  352. package/src/state-graph.ts +9 -8
  353. package/src/substitution-levels.ts +2 -2
  354. package/src/successors.ts +39 -23
  355. package/src/symmetry.ts +1 -1
  356. package/src/tableau.ts +6 -7
  357. package/src/tlc/fingerprint.ts +214 -0
  358. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  359. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  360. package/src/{tlc-random.ts → tlc/random.ts} +3 -190
  361. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  362. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  363. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  364. package/src/{tlc-version.ts → tlc/version.ts} +8 -7
  365. package/src/transfer.ts +32 -32
  366. package/src/values.ts +166 -111
  367. package/src/worker.ts +62 -0
  368. package/dist/parallel.cjs +0 -12
  369. package/dist/parallel.js +0 -12
  370. package/dist/run-cli.cjs +0 -55
  371. package/dist/run-cli.js +0 -55
  372. package/src/canonical.ts +0 -40
  373. package/src/obligation-expression.ts +0 -1060
  374. package/src/obligation-module.ts +0 -1042
  375. package/src/standard-ranges.ts +0 -116
  376. package/src/value-sources.ts +0 -29
  377. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  378. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
package/src/evaluate.ts CHANGED
@@ -16,12 +16,12 @@ import { getKindString } from "./builtins";
16
16
  import { isStackOverflow, TlaEvaluationError, TlaUnassignedError } from "./errors";
17
17
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
18
18
  import { generateEvaluator } from "./codegen";
19
- import { MESSAGE_CODE } from "./tlc-messages";
19
+ import { MESSAGE_CODE } from "./tlc/messages";
20
20
  import type { CheckerRuntime } from "./runtime";
21
21
  import { getReadVariables } from "./dependencies";
22
22
  import { contextualApplications, mapChildren, substitutedExpressions } from "./instances";
23
23
  import { prettyPrint } from "./pretty-print";
24
- import { isEnabled } from "./successors";
24
+ import { getReadLocals, isEnabled } from "./successors";
25
25
  import {
26
26
  applyFunction,
27
27
  describeMissingArgument,
@@ -54,8 +54,8 @@ import {
54
54
  markLambdaFunction,
55
55
  isReducibleSet,
56
56
  isSetValue,
57
- MAXIMUM_INTEGER,
58
- MINIMUM_INTEGER,
57
+ isSettledValue,
58
+ isTlcInteger,
59
59
  toFiniteFunction,
60
60
  toFiniteSet,
61
61
  updateFunction,
@@ -68,7 +68,7 @@ import {
68
68
  markNormalized,
69
69
  setTrace,
70
70
  } from "./values";
71
- import type { TlcVersion } from "./tlc-version";
71
+ import type { TlcVersion } from "./tlc/version";
72
72
 
73
73
  export type State = (Value | undefined)[];
74
74
 
@@ -113,6 +113,9 @@ export interface Thunk {
113
113
  state: State | undefined;
114
114
  next: State | undefined;
115
115
  cache: Value | undefined;
116
+ // Whether the expression may build a set that streams until TLC caches it, so that the thunk
117
+ // caches only a settled value.
118
+ isStreamed: boolean;
116
119
  }
117
120
 
118
121
  type Binding = { kind: "Value"; value: Value } | Thunk | { kind: "Operator"; operator: Operator };
@@ -248,14 +251,14 @@ export const describeNode = (expression: Expression) =>
248
251
  ? (expression.text ?? String(expression.value))
249
252
  : describeRange(expression);
250
253
 
251
- export const getConditionError = (expression: Expression, value: Value) =>
254
+ export const createConditionError = (expression: Expression, value: Value) =>
252
255
  new TlaEvaluationError(
253
256
  `A non-boolean expression (${getKindString(value)}) was used as the condition of an IF.\n${describeRange(expression)}`,
254
257
  );
255
258
 
256
259
  // TLC parses an infix chain of /\ or \/ as nested binary junctions and a bulleted list as one
257
260
  // junction list, and it words the error differently for each.
258
- export const getJunctionError = (
261
+ export const createJunctionError = (
259
262
  expression: Expression & { kind: "And" | "Or" },
260
263
  index: number,
261
264
  value: Value,
@@ -344,6 +347,27 @@ export const createBigNumberError = (expression: NumberExpression) =>
344
347
  EXIT_STATUS.error,
345
348
  );
346
349
 
350
+ // TLC's Tool#evalAppl fails to look up a variable the state doesn't assign.
351
+ export const createUnassignedError = (name: string, expression: Expression) =>
352
+ new TlaUnassignedError(
353
+ `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
354
+ name,
355
+ );
356
+
357
+ // TLC's Tool#enabled reads the subscript of <<A>>_v in the successor as a state of its own, and
358
+ // names the fairness condition when A leaves a variable of v unassigned, unlike TLC 1.7.4's.
359
+ export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion | undefined) =>
360
+ error instanceof TlaUnassignedError && version !== "1.7.4"
361
+ ? new TlaEvaluationError(
362
+ `The action formula A appearing in a WF_v(A) or SF_v(A) operator does not specify the primed value of the variable ${error.variable} occurring in the state formula v.\n`,
363
+ )
364
+ : error;
365
+
366
+ export const createPrimeOutsideActionError = (expression: Expression) =>
367
+ new TlaEvaluationError(
368
+ `A primed expression appears outside an action at ${describeLocation(expression)}`,
369
+ );
370
+
347
371
  export const lookupScope = (scope: Scope | undefined, name: string): Binding | undefined => {
348
372
  for (let current = scope; current; current = current.parent) {
349
373
  if (current.name === name) return current.binding;
@@ -380,7 +404,15 @@ export const expectFunction = (value: Value, application: Expression) => {
380
404
  };
381
405
 
382
406
  export const toKeepLazyContext = (context: Context): Context =>
383
- context.isKeepLazy ? context : { ...context, isKeepLazy: true };
407
+ context.isKeepLazy
408
+ ? context
409
+ : {
410
+ environment: context.environment,
411
+ scope: context.scope,
412
+ state: context.state,
413
+ next: context.next,
414
+ isKeepLazy: true,
415
+ };
384
416
 
385
417
  const withScope = (context: Context, scope: Scope | undefined): Context => ({
386
418
  environment: context.environment,
@@ -555,12 +587,12 @@ export const forEachBinding = (
555
587
  visit: (scope: Scope | undefined) => boolean,
556
588
  ) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
557
589
 
558
- export const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
590
+ const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
559
591
  const sets = bounds.map((bound) => evaluate(bound.set, context));
560
592
  return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
561
593
  };
562
594
 
563
- export const bindArgument = (bounds: Bound[], scope: Scope | undefined, argument: Value) => {
595
+ const bindArgument = (bounds: Bound[], scope: Scope | undefined, argument: Value) => {
564
596
  if (bounds.length === 1) return bindPattern(scope, bounds[0].pattern, argument);
565
597
  const components = getSequenceElements(argument) ?? [];
566
598
  return bounds.reduce<Scope | undefined>(
@@ -578,15 +610,19 @@ interface LazyFunction {
578
610
  scope: Scope | undefined;
579
611
  }
580
612
 
581
- const lazyFunctions = new WeakMap<LazyFunctionValue, LazyFunction>();
613
+ // The function keeps its parameters, body and scope itself, since a WeakMap entry for each
614
+ // short-lived function makes every garbage collection slower.
615
+ interface KeptLazyFunctionValue extends LazyFunctionValue {
616
+ lambda: LazyFunction;
617
+ }
582
618
 
583
- const keepLambda = (lambda: LazyFunction) => {
584
- lazyFunctions.set(lambda.value, lambda);
585
- return lambda.value;
586
- };
619
+ const isKeptLazyFunction = (value: Value): value is KeptLazyFunctionValue =>
620
+ typeof value === "object" && value.kind === "LazyFunction" && "lambda" in value;
621
+
622
+ const keepLambda = (lambda: LazyFunction) => Object.assign(lambda.value, { lambda });
587
623
 
588
624
  export const getLazyFunction = (value: Value) =>
589
- typeof value === "object" && value.kind === "LazyFunction" ? lazyFunctions.get(value) : undefined;
625
+ isKeptLazyFunction(value) ? value.lambda : undefined;
590
626
 
591
627
  // Tool.getFcnContext: the scope of a lazy function's body for the arguments of an application. It
592
628
  // ignores arguments beyond the parameters.
@@ -835,7 +871,7 @@ const forceThunk = (thunk: Thunk, context: Context) => {
835
871
  const isSameState = thunk.state === context.state && thunk.next === context.next;
836
872
  if (isSameState && thunk.cache !== undefined) return thunk.cache;
837
873
  const value = evaluate(thunk.expression, withScope(context, thunk.scope));
838
- if (isSameState) thunk.cache = value;
874
+ if (isSameState && (!thunk.isStreamed || isSettledValue(value))) thunk.cache = value;
839
875
  return value;
840
876
  };
841
877
 
@@ -949,6 +985,18 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
949
985
  return operator !== undefined && getArity(operator) > 0;
950
986
  };
951
987
 
988
+ const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
989
+ args.map((arg) =>
990
+ isOperatorArgument(arg, context)
991
+ ? toOperatorValue(evaluateOperatorArgument(arg, context), context)
992
+ : evaluate(arg, context),
993
+ );
994
+
995
+ const createArityError = (closure: Closure, count: number) =>
996
+ new TlaEvaluationError(
997
+ `Operator ${closure.name} expects ${closure.params.length} arguments but received ${count}`,
998
+ );
999
+
952
1000
  const createThunk = (expression: Expression, context: Context): Thunk => ({
953
1001
  kind: "Thunk",
954
1002
  expression,
@@ -956,6 +1004,7 @@ const createThunk = (expression: Expression, context: Context): Thunk => ({
956
1004
  state: context.state,
957
1005
  next: context.next,
958
1006
  cache: undefined,
1007
+ isStreamed: false,
959
1008
  });
960
1009
 
961
1010
  export const findGlobalName = (name: string, environment: Environment): GlobalName | undefined => {
@@ -1015,47 +1064,61 @@ export const bindOperatorArguments = (
1015
1064
  closure: Closure,
1016
1065
  args: Expression[],
1017
1066
  context: Context,
1067
+ binders?: ArgumentBinder[],
1018
1068
  ): Scope | undefined => {
1019
- if (args.length !== closure.params.length) {
1020
- throw new TlaEvaluationError(
1021
- `Operator ${closure.name} expects ${closure.params.length} arguments but received ${args.length}`,
1022
- );
1023
- }
1069
+ if (args.length !== closure.params.length) throw createArityError(closure, args.length);
1024
1070
  let scope = closure.scope;
1025
1071
  for (let index = 0; index < args.length; index++) {
1026
1072
  const param = closure.params[index];
1027
1073
  const binding: Binding =
1028
1074
  param.arity > 0
1029
1075
  ? { kind: "Operator", operator: evaluateOperatorArgument(args[index], context) }
1030
- : getArgumentBinder(args[index], context.environment)(context);
1076
+ : (binders?.[index] ?? getArgumentBinder(args[index], context.environment))(context);
1031
1077
  scope = { name: param.name, binding, parent: scope };
1032
1078
  }
1033
1079
  return scope;
1034
1080
  };
1035
1081
 
1036
- const callOperator = (operator: Operator, args: Expression[], context: Context) => {
1082
+ // The body a call site last called and its evaluator, as a site mostly calls one closure.
1083
+ interface CalledBody {
1084
+ body: Expression;
1085
+ evaluator: Evaluator;
1086
+ }
1087
+
1088
+ const callOperator = (
1089
+ operator: Operator,
1090
+ args: Expression[],
1091
+ context: Context,
1092
+ called: { entry: CalledBody | undefined },
1093
+ binders: ArgumentBinder[],
1094
+ ) => {
1037
1095
  if (operator.kind === "Closure") {
1038
- return evaluate(
1039
- operator.body,
1040
- withScope(context, bindOperatorArguments(operator, args, context)),
1041
- );
1096
+ const bodyContext = withScope(context, bindOperatorArguments(operator, args, context, binders));
1097
+ if (context.environment.callStack) return evaluate(operator.body, bodyContext);
1098
+ const entry =
1099
+ called.entry?.body === operator.body
1100
+ ? called.entry
1101
+ : (called.entry = {
1102
+ body: operator.body,
1103
+ evaluator: getEntryEvaluator(operator.body, context.environment),
1104
+ });
1105
+ return entry.evaluator(bodyContext);
1042
1106
  }
1043
1107
  if (operator.kind === "Operator") return operator.call(args.map((arg) => evaluate(arg, context)));
1044
1108
  if (operator.isLazy) return operator.evaluate(getLazyArguments(args, context), context);
1045
- return operator.evaluate(
1046
- args.map((arg) =>
1047
- isOperatorArgument(arg, context)
1048
- ? toOperatorValue(evaluateOperatorArgument(arg, context), context)
1049
- : evaluate(arg, context),
1050
- ),
1051
- context,
1052
- );
1109
+ return operator.evaluate(evaluateBuiltinArguments(args, context), context);
1053
1110
  };
1054
1111
 
1112
+ // The LET definitions that a reference evaluates again, and those that cache only a settled value.
1113
+ interface ReevaluatedDefinitions {
1114
+ impure: ReadonlySet<Definition>;
1115
+ streamed: ReadonlySet<Definition>;
1116
+ }
1117
+
1055
1118
  export const bindDefinitions = (
1056
1119
  definitions: Definition[],
1057
1120
  context: Context,
1058
- reevaluated?: ReadonlySet<Definition>,
1121
+ reevaluated?: ReevaluatedDefinitions,
1059
1122
  ): Scope | undefined =>
1060
1123
  definitions.reduce<Scope | undefined>((scope, definition) => {
1061
1124
  const node: Scope = {
@@ -1077,10 +1140,11 @@ export const bindDefinitions = (
1077
1140
  state: context.state,
1078
1141
  next: context.next,
1079
1142
  cache: undefined,
1143
+ isStreamed: false,
1080
1144
  };
1081
1145
  return node;
1082
1146
  }
1083
- if (definition.params.length > 0 || reevaluated?.has(definition)) {
1147
+ if (definition.params.length > 0 || reevaluated?.impure.has(definition)) {
1084
1148
  node.binding = {
1085
1149
  kind: "Operator",
1086
1150
  operator: {
@@ -1100,6 +1164,7 @@ export const bindDefinitions = (
1100
1164
  state: context.state,
1101
1165
  next: context.next,
1102
1166
  cache: undefined,
1167
+ isStreamed: reevaluated?.streamed.has(definition) ?? false,
1103
1168
  };
1104
1169
  return node;
1105
1170
  }, context.scope);
@@ -1127,9 +1192,6 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
1127
1192
  throw new TlaEvaluationError(`Unknown identifier ${name} at ${describeLocation(expression)}`);
1128
1193
  };
1129
1194
 
1130
- export const isTlcInteger = (value: number) =>
1131
- Number.isInteger(value) && value <= MAXIMUM_INTEGER && value >= MINIMUM_INTEGER;
1132
-
1133
1195
  const IMPURE_BUILTINS = new Set([
1134
1196
  "Print",
1135
1197
  "PrintT",
@@ -1216,14 +1278,15 @@ const STREAMED_SET: Impurity = {
1216
1278
  // TLC's next-state generator does not bind LET definitions to values, so each reference to one
1217
1279
  // evaluates it again: one that calls an impure builtin repeats its effects, and a set one builds
1218
1280
  // with UNION or \cup starts out uncached.
1219
- export const getReevaluatedDefinitions = (definitions: Definition[], environment: Environment) =>
1220
- new Set(
1221
- definitions.filter(
1222
- (definition) =>
1223
- isImpureDefinition(definition, environment) ||
1224
- isImpureDefinition(definition, environment, STREAMED_SET),
1225
- ),
1226
- );
1281
+ export const getReevaluatedDefinitions = (
1282
+ definitions: Definition[],
1283
+ environment: Environment,
1284
+ ): ReevaluatedDefinitions => ({
1285
+ impure: new Set(definitions.filter((definition) => isImpureDefinition(definition, environment))),
1286
+ streamed: new Set(
1287
+ definitions.filter((definition) => isImpureDefinition(definition, environment, STREAMED_SET)),
1288
+ ),
1289
+ });
1227
1290
 
1228
1291
  export const isImpure = (environment: Environment) =>
1229
1292
  [...environment.definitions.values()].some((definition) =>
@@ -1375,9 +1438,14 @@ const isStateCached = (expression: Expression, environment: Environment) =>
1375
1438
  getReadVariables(expression, environment) !== undefined &&
1376
1439
  !hasFreeLocals(expression, NO_BOUND_NAMES);
1377
1440
 
1378
- // How to rebuild a set filter TLC evaluates lazily so that its predicate runs in another
1441
+ // A set filter TLC evaluates lazily, with how to rebuild it so that its predicate runs in another
1379
1442
  // environment.
1380
- const filteredSetRebinders = new WeakMap<FilteredSetValue, (environment: Environment) => Value>();
1443
+ interface RebindableFilteredSet extends FilteredSetValue {
1444
+ rebind: (environment: Environment) => Value;
1445
+ }
1446
+
1447
+ const isRebindableFilteredSet = (value: Value): value is RebindableFilteredSet =>
1448
+ typeof value === "object" && value.kind === "FilteredSet" && "rebind" in value;
1381
1449
 
1382
1450
  // TLC's CallStackTool rebinds the lazy values its evaluations return, so their later evaluation
1383
1451
  // records its call stack too.
@@ -1398,11 +1466,7 @@ const traceEvaluator =
1398
1466
  setTrace.callStack = callStack;
1399
1467
  try {
1400
1468
  const computed = evaluator(context);
1401
- const rebind =
1402
- typeof computed === "object" && computed.kind === "FilteredSet"
1403
- ? filteredSetRebinders.get(computed)
1404
- : undefined;
1405
- const value = rebind ? rebind(environment) : computed;
1469
+ const value = isRebindableFilteredSet(computed) ? computed.rebind(environment) : computed;
1406
1470
  callStack.values.set(expression, value);
1407
1471
  if (typeof value === "object" && value.kind !== "FilteredSet" && isSourced(expression)) {
1408
1472
  callStack.sources.set(value, expression);
@@ -1506,7 +1570,7 @@ export const getEvaluator = (expression: Expression, environment: Environment):
1506
1570
 
1507
1571
  const entryEvaluators = new WeakMap<Expression, Evaluator>();
1508
1572
 
1509
- const getEntryEvaluator = (expression: Expression, environment: Environment) => {
1573
+ export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
1510
1574
  if (environment.callStack) return getEvaluator(expression, environment);
1511
1575
  const cached = entryEvaluators.get(expression);
1512
1576
  if (cached) return cached;
@@ -1593,20 +1657,13 @@ const cacheStateValue = (evaluator: Evaluator): Evaluator => {
1593
1657
  };
1594
1658
  };
1595
1659
 
1596
- const isOperatorName = (name: string, environment: Environment) => {
1597
- const operator = resolveGlobalOperator(name, environment);
1598
- return operator !== undefined && getArity(operator) > 0;
1660
+ export const isValueArgument = (argument: Expression, environment: Environment) => {
1661
+ if (argument.kind === "Lambda" || argument.kind === "OperatorReference") return false;
1662
+ if (argument.kind !== "Identifier" || isLocallyResolved(argument)) return true;
1663
+ const operator = resolveGlobalOperator(argument.name, environment);
1664
+ return operator === undefined || getArity(operator) === 0;
1599
1665
  };
1600
1666
 
1601
- export const isValueArgument = (argument: Expression, environment: Environment) =>
1602
- argument.kind !== "Lambda" &&
1603
- argument.kind !== "OperatorReference" &&
1604
- !(
1605
- argument.kind === "Identifier" &&
1606
- !isLocallyResolved(argument) &&
1607
- isOperatorName(argument.name, environment)
1608
- );
1609
-
1610
1667
  const getLazyArguments = (args: Expression[], context: Context): OperatorValue[] =>
1611
1668
  args.map((arg) => ({
1612
1669
  kind: "Operator",
@@ -1639,15 +1696,7 @@ const compileBuiltinCall = (
1639
1696
  const right = getEvaluator(args[1], environment);
1640
1697
  return (context) => binary(left(context), right(context));
1641
1698
  }
1642
- return (context) =>
1643
- builtin.evaluate(
1644
- args.map((arg) =>
1645
- isOperatorArgument(arg, context)
1646
- ? toOperatorValue(evaluateOperatorArgument(arg, context), context)
1647
- : evaluate(arg, context),
1648
- ),
1649
- context,
1650
- );
1699
+ return (context) => builtin.evaluate(evaluateBuiltinArguments(args, context), context);
1651
1700
  };
1652
1701
 
1653
1702
  export const compileArgumentScope = (
@@ -1657,9 +1706,7 @@ export const compileArgumentScope = (
1657
1706
  ): ((context: Context) => Scope | undefined) => {
1658
1707
  if (args.length !== closure.params.length) {
1659
1708
  return () => {
1660
- throw new TlaEvaluationError(
1661
- `Operator ${closure.name} expects ${closure.params.length} arguments but received ${args.length}`,
1662
- );
1709
+ throw createArityError(closure, args.length);
1663
1710
  };
1664
1711
  }
1665
1712
  const params = closure.params;
@@ -1680,52 +1727,180 @@ export const compileArgumentScope = (
1680
1727
  };
1681
1728
 
1682
1729
  interface MemoizedCall {
1730
+ sources: (Expression | undefined)[];
1683
1731
  args: Value[];
1684
1732
  value: Value;
1685
1733
  }
1686
1734
 
1687
1735
  const MEMOIZED_CALL_LIMIT = 1 << 16;
1688
1736
 
1689
- const callMemos = new WeakMap<Closure, { calls: Map<number, MemoizedCall[]>; size: number }>();
1737
+ // A call site that finds fewer than half its calls in a state's memo after this many new ones
1738
+ // stops paying for the lookups.
1739
+ const MEMOIZED_TRIAL_CALLS = 1 << 10;
1740
+
1741
+ interface CallMemo {
1742
+ calls: Map<number, MemoizedCall[]>;
1743
+ size: number;
1744
+ state: Context["state"];
1745
+ }
1746
+
1747
+ interface CallMemos {
1748
+ constant: CallMemo;
1749
+ state: CallMemo;
1750
+ }
1751
+
1752
+ const createCallMemo = (): CallMemo => ({ calls: new Map(), size: 0, state: undefined });
1753
+
1754
+ const callMemos = new WeakMap<Closure, CallMemos>();
1690
1755
 
1691
- const getCallMemo = (closure: Closure) => {
1756
+ const getCallMemos = (closure: Closure) => {
1692
1757
  const cached = callMemos.get(closure);
1693
1758
  if (cached) return cached;
1694
- const memo = { calls: new Map<number, MemoizedCall[]>(), size: 0 };
1695
- callMemos.set(closure, memo);
1696
- return memo;
1759
+ const memos = { constant: createCallMemo(), state: createCallMemo() };
1760
+ callMemos.set(closure, memos);
1761
+ return memos;
1697
1762
  };
1698
1763
 
1699
- const getArgumentValues = (scope: Scope | undefined, arity: number) => {
1700
- const values: Value[] = [];
1701
- for (let current = scope; values.length < arity; current = current?.parent) {
1702
- if (current?.binding.kind !== "Value") return undefined;
1703
- values.push(current.binding.value);
1764
+ const readsExceptAt = (expression: Expression): boolean =>
1765
+ expression.kind === "ExceptAt" || getChildren(expression).some(readsExceptAt);
1766
+
1767
+ // The locals an argument expression reads, when the state and their values decide its value. An @
1768
+ // reads the value its EXCEPT binds.
1769
+ const argumentLocals = new WeakMap<Expression, string[] | false>();
1770
+
1771
+ const getArgumentLocals = (expression: Expression, environment: Environment) => {
1772
+ const cached = argumentLocals.get(expression);
1773
+ if (cached !== undefined) return cached;
1774
+ const locals =
1775
+ getReadVariables(expression, environment) !== undefined &&
1776
+ getReadLocals(expression, NO_BOUND_NAMES);
1777
+ const unique = locals && [
1778
+ ...new Set(readsExceptAt(expression) ? [...locals, EXCEPT_AT] : locals),
1779
+ ];
1780
+ argumentLocals.set(expression, unique ?? false);
1781
+ return unique ?? false;
1782
+ };
1783
+
1784
+ // Hashing a lazy set or function would enumerate it, which TLC does only when it has to.
1785
+ const isEagerValue = (value: Value) =>
1786
+ typeof value !== "object" ||
1787
+ value.kind === "ModelValue" ||
1788
+ value.kind === "Set" ||
1789
+ value.kind === "Function" ||
1790
+ value.kind === "Interval";
1791
+
1792
+ // The key of the call being looked up, copied into the memo only when the call is new. Counts
1793
+ // mark its ends, since shortening an array is slow.
1794
+ const callKey = {
1795
+ sources: [] as (Expression | undefined)[],
1796
+ sourceCount: 0,
1797
+ args: [] as Value[],
1798
+ argCount: 0,
1799
+ hash: 0,
1800
+ isStateKeyed: false,
1801
+ };
1802
+
1803
+ // A model value's rank tells it apart without hashing its name.
1804
+ const getKeyHash = (value: Value) =>
1805
+ typeof value === "object" && value.kind === "ModelValue" ? value.rank : getValueHash(value);
1806
+
1807
+ const pushKeyValue = (value: Value) => {
1808
+ if (!isEagerValue(value)) return false;
1809
+ callKey.sources[callKey.sourceCount++] = undefined;
1810
+ callKey.args[callKey.argCount++] = value;
1811
+ callKey.hash = combineHash(callKey.hash, getKeyHash(value));
1812
+ return true;
1813
+ };
1814
+
1815
+ // An argument TLC has not evaluated yet stands for its expression and the values of the locals it
1816
+ // reads, so a call keeps the laziness of its arguments.
1817
+ const pushKeyExpression = (
1818
+ expression: Expression,
1819
+ locals: string[] | false,
1820
+ scope: Scope | undefined,
1821
+ ) => {
1822
+ if (!locals) return false;
1823
+ callKey.sources[callKey.sourceCount++] = expression;
1824
+ callKey.isStateKeyed = true;
1825
+ for (let index = 0; index < locals.length; index++) {
1826
+ const local = lookupScope(scope, locals[index]);
1827
+ if (local?.kind !== "Value" || !isEagerValue(local.value)) return false;
1828
+ callKey.args[callKey.argCount++] = local.value;
1829
+ callKey.hash = combineHash(callKey.hash, getKeyHash(local.value));
1830
+ }
1831
+ return true;
1832
+ };
1833
+
1834
+ // Each argument adds to the key what compileArgumentBinder would bind its parameter to.
1835
+ const compileArgumentKey = (
1836
+ argument: Expression,
1837
+ environment: Environment,
1838
+ ): ((context: Context) => boolean) => {
1839
+ const isLiteral =
1840
+ argument.kind === "String" || (argument.kind === "Number" && isTlcInteger(argument.value));
1841
+ if (isLiteral) return () => pushKeyValue(argument.value);
1842
+ if (argument.kind === "Identifier") {
1843
+ const global = isLocallyResolved(argument)
1844
+ ? undefined
1845
+ : findGlobalName(argument.name, environment);
1846
+ if (global?.kind === "Value") return () => pushKeyValue(global.value);
1847
+ if (global === undefined) {
1848
+ return (context) => {
1849
+ const binding = lookupScope(context.scope, argument.name);
1850
+ if (binding?.kind === "Value") return pushKeyValue(binding.value);
1851
+ if (binding?.kind !== "Thunk" || binding.state !== context.state) return false;
1852
+ return pushKeyExpression(
1853
+ binding.expression,
1854
+ getArgumentLocals(binding.expression, environment),
1855
+ binding.scope,
1856
+ );
1857
+ };
1858
+ }
1704
1859
  }
1705
- return values;
1860
+ const locals = getArgumentLocals(argument, environment);
1861
+ return (context) => pushKeyExpression(argument, locals, context.scope);
1706
1862
  };
1707
1863
 
1708
- const isSameArguments = (left: Value[], right: Value[]) =>
1709
- left.every((value, index) => isSameValue(value, right[index]));
1864
+ const isKnownCall = (call: MemoizedCall) => {
1865
+ if (call.args.length !== callKey.argCount || call.sources.length !== callKey.sourceCount) {
1866
+ return false;
1867
+ }
1868
+ for (let index = 0; index < callKey.sourceCount; index++) {
1869
+ if (call.sources[index] !== callKey.sources[index]) return false;
1870
+ }
1871
+ for (let index = 0; index < callKey.argCount; index++) {
1872
+ if (!isSameValue(call.args[index], callKey.args[index])) return false;
1873
+ }
1874
+ return true;
1875
+ };
1710
1876
 
1711
- // A constant-level operator without side effects yields the same value for the same arguments,
1712
- // so its calls with evaluated arguments share one result.
1713
- const isMemoizable = (expression: Expression & { kind: "Apply" }, environment: Environment) => {
1877
+ const findCall = (bucket: MemoizedCall[] | undefined) => {
1878
+ if (bucket === undefined) return undefined;
1879
+ for (let index = 0; index < bucket.length; index++) {
1880
+ if (isKnownCall(bucket[index])) return bucket[index];
1881
+ }
1882
+ return undefined;
1883
+ };
1884
+
1885
+ // An operator without side effects yields the same value for the same arguments, a state-level one
1886
+ // in the same state, so its calls share one result.
1887
+ const getMemoizedLevel = (expression: Expression & { kind: "Apply" }, environment: Environment) => {
1714
1888
  const definition = getDefinition(expression.operator, environment);
1715
- return (
1889
+ const isMemoizable =
1716
1890
  definition?.kind === "Operator" &&
1717
1891
  definition.params.length > 0 &&
1718
1892
  definition.params.every((param) => param.arity === 0) &&
1719
- isConstantLevel(definition, environment) &&
1720
- !isImpureDefinition(definition, environment)
1721
- );
1893
+ !isImpureDefinition(definition, environment);
1894
+ if (!isMemoizable) return undefined;
1895
+ if (isConstantLevel(definition, environment)) return "constant";
1896
+ return isStatePure(definition, environment) ? "state" : undefined;
1722
1897
  };
1723
1898
 
1724
1899
  const compileClosureCall = (
1725
1900
  closure: Closure,
1726
1901
  args: Expression[],
1727
1902
  environment: Environment,
1728
- isMemoized: boolean,
1903
+ memoizedLevel: "constant" | "state" | undefined,
1729
1904
  ): Evaluator => {
1730
1905
  const bindArguments = compileArgumentScope(closure, args, environment);
1731
1906
  const compiled = { body: undefined as Evaluator | undefined };
@@ -1739,23 +1914,49 @@ const compileClosureCall = (
1739
1914
  isKeepLazy: context.isKeepLazy,
1740
1915
  });
1741
1916
  };
1742
- if (!isMemoized) return (context) => evaluateBody(bindArguments(context), context);
1743
- const memo = getCallMemo(closure);
1917
+ if (!memoizedLevel || args.length !== closure.params.length) {
1918
+ return (context) => evaluateBody(bindArguments(context), context);
1919
+ }
1920
+ const memos = getCallMemos(closure);
1921
+ const keys = args.map((arg) => compileArgumentKey(arg, environment));
1922
+ const usage = { hits: 0, misses: 0 };
1744
1923
  return (context) => {
1745
- const scope = bindArguments(context);
1746
- const values = getArgumentValues(scope, args.length);
1747
1924
  // A call TLC evaluates with EvalControl.KeepLazy builds what a memoized one wouldn't.
1748
- if (!values || context.isKeepLazy) return evaluateBody(scope, context);
1749
- let hash = values.length;
1750
- for (const value of values) hash = combineHash(hash, getValueHash(value));
1925
+ if (context.isKeepLazy) return evaluateBody(bindArguments(context), context);
1926
+ callKey.sourceCount = 0;
1927
+ callKey.argCount = 0;
1928
+ callKey.hash = args.length;
1929
+ callKey.isStateKeyed = false;
1930
+ for (let index = 0; index < keys.length; index++) {
1931
+ if (!keys[index](context)) return evaluateBody(bindArguments(context), context);
1932
+ }
1933
+ const isStateKeyed = memoizedLevel === "state" || callKey.isStateKeyed;
1934
+ if (isStateKeyed && usage.misses > MEMOIZED_TRIAL_CALLS && usage.hits < usage.misses) {
1935
+ return evaluateBody(bindArguments(context), context);
1936
+ }
1937
+ const memo = isStateKeyed ? memos.state : memos.constant;
1938
+ if (isStateKeyed && memo.state !== context.state) {
1939
+ memo.state = context.state;
1940
+ memo.calls.clear();
1941
+ memo.size = 0;
1942
+ }
1943
+ // A small integer key keeps the Map from boxing it.
1944
+ const hash = callKey.hash & 0x3fffffff;
1751
1945
  const bucket = memo.calls.get(hash);
1752
- const known = bucket?.find((call) => isSameArguments(call.args, values));
1753
- if (known) return known.value;
1754
- const value = evaluateBody(scope, context);
1946
+ const known = findCall(bucket);
1947
+ if (known) {
1948
+ if (isStateKeyed) usage.hits++;
1949
+ return known.value;
1950
+ }
1951
+ if (isStateKeyed) usage.misses++;
1952
+ const sources = callKey.sources.slice(0, callKey.sourceCount);
1953
+ const keyArgs = callKey.args.slice(0, callKey.argCount);
1954
+ const value = evaluateBody(bindArguments(context), context);
1755
1955
  if (memo.size < MEMOIZED_CALL_LIMIT) {
1756
1956
  memo.size++;
1757
- if (bucket) bucket.push({ args: values, value });
1758
- else memo.calls.set(hash, [{ args: values, value }]);
1957
+ const call = { sources, args: keyArgs, value };
1958
+ if (bucket) bucket.push(call);
1959
+ else memo.calls.set(hash, [call]);
1759
1960
  }
1760
1961
  return value;
1761
1962
  };
@@ -1783,8 +1984,10 @@ const compileApply = (
1783
1984
  : resolveGlobalOperator(expression.operator, environment);
1784
1985
  if (global?.kind === "Closure") {
1785
1986
  // The replay records the evaluation of each call, which TLC repeats.
1786
- const isMemoized = !environment.callStack && isMemoizable(expression, environment);
1787
- return compileClosureCall(global, args, environment, isMemoized);
1987
+ const memoizedLevel = environment.callStack
1988
+ ? undefined
1989
+ : getMemoizedLevel(expression, environment);
1990
+ return compileClosureCall(global, args, environment, memoizedLevel);
1788
1991
  }
1789
1992
  if (global?.kind === "Builtin" && global.name === "DOMAIN") {
1790
1993
  const operand = getEvaluator(args[0], environment);
@@ -1817,9 +2020,11 @@ const compileApply = (
1817
2020
  );
1818
2021
  };
1819
2022
  }
2023
+ const called = { entry: undefined as CalledBody | undefined };
2024
+ const binders = args.map((arg) => getArgumentBinder(arg, environment));
1820
2025
  return (context) => {
1821
2026
  const operator = resolveOperator(expression.operator, context);
1822
- if (operator) return callOperator(operator, args, context);
2027
+ if (operator) return callOperator(operator, args, context, called, binders);
1823
2028
  const definition = environment.definitions.get(expression.operator);
1824
2029
  if (definition?.kind === "Function") {
1825
2030
  throw new TlaEvaluationError(`${expression.operator} is a function; apply it with brackets`);
@@ -1882,7 +2087,7 @@ const compileQuantifier = (
1882
2087
  };
1883
2088
  };
1884
2089
 
1885
- const lookupKey = (pattern: BoundPattern, scope: Scope | undefined) => {
2090
+ const getBoundValue = (pattern: BoundPattern, scope: Scope | undefined) => {
1886
2091
  if (pattern.kind === "Tuple") {
1887
2092
  return createTuple(
1888
2093
  pattern.names.map((name) => {
@@ -1937,8 +2142,8 @@ const compileFunctionConstruction = (
1937
2142
  forEachBoundElement(bounds, sets, context.scope, (scope) => {
1938
2143
  const key =
1939
2144
  bounds.length === 1
1940
- ? (lookupKey(bound.pattern, scope) ?? false)
1941
- : createTuple(bounds.map((item) => lookupKey(item.pattern, scope) ?? false));
2145
+ ? (getBoundValue(bound.pattern, scope) ?? false)
2146
+ : createTuple(bounds.map((item) => getBoundValue(item.pattern, scope) ?? false));
1942
2147
  pairs.push([key, body(withScope(context, scope))]);
1943
2148
  return false;
1944
2149
  });
@@ -2069,22 +2274,18 @@ const compileSetComprehension = (
2069
2274
  base: Value,
2070
2275
  context: Context,
2071
2276
  evaluator: Evaluator,
2072
- ): FilteredSetValue => {
2073
- const filtered: FilteredSetValue = {
2074
- kind: "FilteredSet",
2075
- base,
2076
- test: createTest(evaluator, context),
2077
- source,
2078
- };
2079
- filteredSetRebinders.set(filtered, (tracing) =>
2277
+ ): RebindableFilteredSet => ({
2278
+ kind: "FilteredSet",
2279
+ base,
2280
+ test: createTest(evaluator, context),
2281
+ source,
2282
+ rebind: (tracing) =>
2080
2283
  createFiltered(
2081
2284
  base,
2082
2285
  { ...context, environment: tracing },
2083
2286
  getEvaluator(expression.predicate, tracing),
2084
2287
  ),
2085
- );
2086
- return filtered;
2087
- };
2288
+ });
2088
2289
  return (context) => {
2089
2290
  const base = set(context);
2090
2291
  // TLC filters any value it can't enumerate lazily, and fails only when it uses the result.
@@ -2125,7 +2326,7 @@ const compileSetComprehension = (
2125
2326
  someElement(elements, (element) => {
2126
2327
  const scope = bindPattern(context.scope, expression.pattern, element);
2127
2328
  if (!expectBoolean(body(withScope(context, scope)), "the body of CHOOSE")) return false;
2128
- chosen.value = lookupKey(expression.pattern, scope);
2329
+ chosen.value = getBoundValue(expression.pattern, scope);
2129
2330
  return true;
2130
2331
  });
2131
2332
  if (chosen.value === undefined) {
@@ -2144,27 +2345,6 @@ export const getSortedFields = (fields: RecordField[]) =>
2144
2345
  export const hasDuplicateFields = (sortedFields: RecordField[]) =>
2145
2346
  sortedFields.some((field, index) => index > 0 && sortedFields[index - 1].name === field.name);
2146
2347
 
2147
- // TLC's Tool#evalAppl fails to look up a variable the state doesn't assign.
2148
- export const createUnassignedError = (name: string, expression: Expression) =>
2149
- new TlaUnassignedError(
2150
- `In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
2151
- name,
2152
- );
2153
-
2154
- // TLC's Tool#enabled reads the subscript of <<A>>_v in the successor as a state of its own, and
2155
- // names the fairness condition when A leaves a variable of v unassigned, unlike TLC 1.7.4's.
2156
- export const toUnspecifiedSubscriptError = (error: unknown, version: TlcVersion | undefined) =>
2157
- error instanceof TlaUnassignedError && version !== "1.7.4"
2158
- ? new TlaEvaluationError(
2159
- `The action formula A appearing in a WF_v(A) or SF_v(A) operator does not specify the primed value of the variable ${error.variable} occurring in the state formula v.\n`,
2160
- )
2161
- : error;
2162
-
2163
- export const createPrimeOutsideActionError = (expression: Expression) =>
2164
- new TlaEvaluationError(
2165
- `A primed expression appears outside an action at ${describeLocation(expression)}`,
2166
- );
2167
-
2168
2348
  const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
2169
2349
  const fields = getSortedFields(recordFields);
2170
2350
  const hasDuplicates = hasDuplicateFields(fields);
@@ -2193,7 +2373,7 @@ const compileRecord = (recordFields: RecordField[], environment: Environment): E
2193
2373
  };
2194
2374
 
2195
2375
  const compile = (expression: Expression, environment: Environment): Evaluator => {
2196
- const child = (node: Expression) => getEvaluator(node, environment);
2376
+ const getChildEvaluator = (node: Expression) => getEvaluator(node, environment);
2197
2377
  switch (expression.kind) {
2198
2378
  case "Number": {
2199
2379
  const value = expression.value;
@@ -2229,29 +2409,29 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2229
2409
  );
2230
2410
  };
2231
2411
  case "And": {
2232
- const operands = expression.operands.map(child);
2412
+ const operands = expression.operands.map(getChildEvaluator);
2233
2413
  return (context) => {
2234
2414
  for (let index = 0; index < operands.length; index++) {
2235
2415
  const value = operands[index](context);
2236
- if (typeof value !== "boolean") throw getJunctionError(expression, index, value);
2416
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2237
2417
  if (!value) return false;
2238
2418
  }
2239
2419
  return true;
2240
2420
  };
2241
2421
  }
2242
2422
  case "Or": {
2243
- const operands = expression.operands.map(child);
2423
+ const operands = expression.operands.map(getChildEvaluator);
2244
2424
  return (context) => {
2245
2425
  for (let index = 0; index < operands.length; index++) {
2246
2426
  const value = operands[index](context);
2247
- if (typeof value !== "boolean") throw getJunctionError(expression, index, value);
2427
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2248
2428
  if (value) return true;
2249
2429
  }
2250
2430
  return false;
2251
2431
  };
2252
2432
  }
2253
2433
  case "Prime": {
2254
- const inner = child(expression.expression);
2434
+ const inner = getChildEvaluator(expression.expression);
2255
2435
  return (context) => {
2256
2436
  if (!context.next) throw createPrimeOutsideActionError(expression);
2257
2437
  return inner({
@@ -2264,31 +2444,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2264
2444
  };
2265
2445
  }
2266
2446
  case "Unchanged": {
2267
- const primed = child({
2447
+ const primed = getChildEvaluator({
2268
2448
  kind: "Prime",
2269
2449
  expression: expression.expression,
2270
2450
  location: expression.location,
2271
2451
  });
2272
- const current = child(expression.expression);
2452
+ const current = getChildEvaluator(expression.expression);
2273
2453
  return (context) => valuesEqual(primed(context), current(context));
2274
2454
  }
2275
2455
  case "If": {
2276
- const condition = child(expression.condition);
2277
- const consequent = child(expression.consequent);
2278
- const alternative = child(expression.alternative);
2456
+ const condition = getChildEvaluator(expression.condition);
2457
+ const consequent = getChildEvaluator(expression.consequent);
2458
+ const alternative = getChildEvaluator(expression.alternative);
2279
2459
  return (context) => {
2280
2460
  const value = condition(context);
2281
- if (typeof value !== "boolean") throw getConditionError(expression, value);
2461
+ if (typeof value !== "boolean") throw createConditionError(expression, value);
2282
2462
  return value ? consequent(context) : alternative(context);
2283
2463
  };
2284
2464
  }
2285
2465
  case "Case": {
2286
2466
  const arms = expression.arms.map((arm) => ({
2287
2467
  source: arm.condition,
2288
- condition: child(arm.condition),
2289
- body: child(arm.body),
2468
+ condition: getChildEvaluator(arm.condition),
2469
+ body: getChildEvaluator(arm.body),
2290
2470
  }));
2291
- const other = expression.other ? child(expression.other) : undefined;
2471
+ const other = expression.other ? getChildEvaluator(expression.other) : undefined;
2292
2472
  return (context) => {
2293
2473
  for (const arm of arms) {
2294
2474
  const value = arm.condition(context);
@@ -2306,7 +2486,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2306
2486
  };
2307
2487
  }
2308
2488
  case "Let": {
2309
- const body = child(expression.body);
2489
+ const body = getChildEvaluator(expression.body);
2310
2490
  return (context) =>
2311
2491
  body(withScope(context, bindDefinitions(expression.definitions, context)));
2312
2492
  }
@@ -2324,18 +2504,18 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2324
2504
  case "SetMap":
2325
2505
  return compileSetComprehension(expression, environment);
2326
2506
  case "SetEnumeration": {
2327
- const elements = expression.elements.map(child);
2507
+ const elements = expression.elements.map(getChildEvaluator);
2328
2508
  return (context) => createEnumeratedSet(elements.map((element) => element(context)));
2329
2509
  }
2330
2510
  case "Tuple": {
2331
- const elements = expression.elements.map(child);
2511
+ const elements = expression.elements.map(getChildEvaluator);
2332
2512
  return (context) => createTuple(elements.map((element) => element(context)));
2333
2513
  }
2334
2514
  case "FunctionConstruction":
2335
2515
  return compileFunctionConstruction(expression, environment);
2336
2516
  case "FunctionSet": {
2337
- const domain = child(expression.domain);
2338
- const range = child(expression.range);
2517
+ const domain = getChildEvaluator(expression.domain);
2518
+ const range = getChildEvaluator(expression.range);
2339
2519
  return (context) => ({ kind: "FunctionSet", domain: domain(context), range: range(context) });
2340
2520
  }
2341
2521
  case "Record":
@@ -2343,7 +2523,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2343
2523
  case "RecordSet": {
2344
2524
  const fields = getSortedFields(expression.fields);
2345
2525
  const names = fields.map((field) => field.name);
2346
- const sets = fields.map((field) => child(field.value));
2526
+ const sets = fields.map((field) => getChildEvaluator(field.value));
2347
2527
  return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2348
2528
  }
2349
2529
  case "Except":
@@ -2360,10 +2540,10 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2360
2540
  };
2361
2541
  case "FunctionApplication": {
2362
2542
  keepLazy(expression.function);
2363
- const evaluated = child(expression.function);
2543
+ const evaluated = getChildEvaluator(expression.function);
2364
2544
  const evaluateFunction = (context: Context) =>
2365
2545
  expectFunction(evaluated(toKeepLazyContext(context)), expression);
2366
- const args = expression.args.map(child);
2546
+ const args = expression.args.map(getChildEvaluator);
2367
2547
  const describeMissing = getMissingArgumentDescriber(environment.runtime.version);
2368
2548
  if (args.length === 1) {
2369
2549
  const argument = args[0];
@@ -2378,12 +2558,12 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2378
2558
  );
2379
2559
  }
2380
2560
  case "FieldAccess": {
2381
- const record = child(expression.record);
2561
+ const record = getChildEvaluator(expression.record);
2382
2562
  const select = getFieldSelector(expression);
2383
2563
  return (context) => select(record(context));
2384
2564
  }
2385
2565
  case "Product": {
2386
- const factors = expression.factors.map(child);
2566
+ const factors = expression.factors.map(getChildEvaluator);
2387
2567
  return (context) => ({
2388
2568
  kind: "ProductSet",
2389
2569
  factors: factors.map((factor) => factor(context)),
@@ -2391,8 +2571,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2391
2571
  }
2392
2572
  case "BoxAction":
2393
2573
  case "AngleAction": {
2394
- const action = child(expression.action);
2395
- const unchanged = child({
2574
+ const action = getChildEvaluator(expression.action);
2575
+ const unchanged = getChildEvaluator({
2396
2576
  kind: "Unchanged",
2397
2577
  expression: expression.subscript,
2398
2578
  location: expression.location,
@@ -2408,7 +2588,7 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2408
2588
  return (context) => isEnabled(action, context);
2409
2589
  }
2410
2590
  case "Label":
2411
- return child(expression.body);
2591
+ return getChildEvaluator(expression.body);
2412
2592
  case "Subexpression":
2413
2593
  return () => {
2414
2594
  throw new TlaEvaluationError(