tla-ts 0.0.4-dev.fa107ef → 0.0.5-dev.cc59f31

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 +37 -126
  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 +44 -12
  8. package/dist/index.d.ts +44 -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 +135 -120
  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} +169 -142
  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 +648 -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 +38 -22
  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 +154 -105
  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/search.ts ADDED
@@ -0,0 +1,969 @@
1
+ import {
2
+ getChildren,
3
+ isLocallyResolved,
4
+ type Assumption,
5
+ type Definition,
6
+ type Expression,
7
+ type SourceLocation,
8
+ } from "./ast";
9
+ import type {
10
+ CheckOptions,
11
+ InitialStatesProgress,
12
+ InitialStateViolation,
13
+ Postcondition,
14
+ Violation,
15
+ } from "./check";
16
+ import type { ConfigValue, ModelConfig } from "./config";
17
+ import { getReadVariables } from "./dependencies";
18
+ import {
19
+ isStackOverflow,
20
+ TlaConfigError,
21
+ TlaEvaluationError,
22
+ TlaModuleError,
23
+ UNEXPECTED_EXCEPTION,
24
+ } from "./errors";
25
+ import {
26
+ describeNode,
27
+ describeRange,
28
+ evaluate,
29
+ evaluateStartupDefinitions,
30
+ expectBoolean,
31
+ formatRange,
32
+ getDefinition,
33
+ isConstantLevel,
34
+ type Context,
35
+ type Environment,
36
+ type Scope,
37
+ } from "./evaluate";
38
+ import { EXIT_STATUS, setExitCode } from "./exit-codes";
39
+ import type { JavaOverride } from "./java-overrides";
40
+ import {
41
+ ACTION_LEVEL,
42
+ CONSTANT_LEVEL,
43
+ createLevelAnalyzer,
44
+ TEMPORAL_LEVEL,
45
+ VARIABLE_LEVEL,
46
+ } from "./levels";
47
+ import { expandTemporal, getLevel, type ScopedExpression, type TemporalProperty } from "./liveness";
48
+ import { prettyPrint } from "./pretty-print";
49
+ import { getPossibleCounts, type CheckerRuntime } from "./runtime";
50
+ import { getRepresentative, getSymmetryGroup } from "./symmetry";
51
+ import { MESSAGE_CODE, MISSING_INIT_174, withHeadline } from "./tlc/messages";
52
+ import { createTlcFingerprinter, getTlcFingerprint } from "./tlc/fingerprint";
53
+ import { formatValue, isUpdatedElementOf, type Value } from "./values";
54
+
55
+ interface NamedExpression {
56
+ name: string;
57
+ expression: Expression;
58
+ scope: Scope | undefined;
59
+ }
60
+
61
+ interface StateCheck extends NamedExpression {
62
+ variables: number[] | undefined;
63
+ membership: Membership | undefined;
64
+ // The whole predicate that TLC evaluates for the check, of which the expression is a conjunct.
65
+ predicate: Expression;
66
+ }
67
+
68
+ // A conjunct `x \in S` whose S reads no variables.
69
+ interface Membership {
70
+ variable: number;
71
+ set: Expression;
72
+ }
73
+
74
+ interface ActionProperty {
75
+ name: string;
76
+ box: Expression;
77
+ action: Expression;
78
+ subscript: Expression;
79
+ scope: Scope | undefined;
80
+ }
81
+
82
+ interface Specification {
83
+ init: Expression | undefined;
84
+ next: Expression | undefined;
85
+ scope: Scope | undefined;
86
+ temporals: ScopedExpression[];
87
+ }
88
+
89
+ interface Properties {
90
+ initialPredicates: NamedExpression[];
91
+ invariants: NamedExpression[];
92
+ actionProperties: ActionProperty[];
93
+ liveness: TemporalProperty[];
94
+ }
95
+
96
+ const START: SourceLocation = { line: 0, column: 0 };
97
+
98
+ export const createIdentifier = (name: string): Expression => ({
99
+ kind: "Identifier",
100
+ name,
101
+ location: START,
102
+ });
103
+
104
+ // TLC leaves the kind out when it rejects arguments to the specification or a property.
105
+ const UNNAMED_ARGUMENT_KINDS = new Set(["name", "property"]);
106
+
107
+ const getConfigOperator = (kind: string, name: string, environment: Environment) => {
108
+ const definition = getDefinition(name, environment);
109
+ if (!definition) {
110
+ throw new TlaConfigError(
111
+ `The ${kind} ${name} specified in the configuration file\nis not defined in the specification.`,
112
+ );
113
+ }
114
+ if (definition.kind === "Operator" && definition.params.length > 0) {
115
+ throw new TlaConfigError(
116
+ UNNAMED_ARGUMENT_KINDS.has(kind)
117
+ ? `TLC requires ${name} not to take any argument.`
118
+ : `TLC requires ${kind} not to take any argument, but one was given: ${name}`,
119
+ );
120
+ }
121
+ return definition;
122
+ };
123
+
124
+ // TLC evaluates every constant definition before it reads the configuration. It keeps a literal
125
+ // number or string, and a definition that fails to evaluate, as an operator.
126
+ const getConstantValue = (name: string, definition: Definition, environment: Environment) => {
127
+ if (!isConstantLevel(definition, environment)) return undefined;
128
+ if (definition.body.kind === "Number" || definition.body.kind === "String") return undefined;
129
+ try {
130
+ return evaluate(createIdentifier(name), getContext(environment, undefined, undefined));
131
+ } catch (error) {
132
+ // TLC swallows whatever the definition throws, a stack overflow included.
133
+ if (error instanceof TlaEvaluationError || isStackOverflow(error)) return undefined;
134
+ throw error;
135
+ }
136
+ };
137
+
138
+ // TLC takes for an operator only a definition it hasn't replaced with its value.
139
+ export const getConfigDefinition = (kind: string, name: string, environment: Environment) => {
140
+ const definition = getConfigOperator(kind, name, environment);
141
+ if (getConstantValue(name, definition, environment) !== undefined) {
142
+ throw new TlaConfigError(`The ${kind} ${name} cannot be a constant.`);
143
+ }
144
+ return definition;
145
+ };
146
+
147
+ // TLC also takes a constant that the configuration assigns a value, which must be TRUE.
148
+ const getConfigPredicate = (kind: string, name: string, environment: Environment) => {
149
+ const definition = environment.constants.has(name)
150
+ ? undefined
151
+ : getConfigOperator(kind, name, environment);
152
+ const value = definition
153
+ ? getConstantValue(name, definition, environment)
154
+ : environment.constants.get(name);
155
+ if (value !== undefined && value !== true) {
156
+ throw new TlaConfigError(`The ${kind} of ${name} is equal to ${formatValue(value)}`);
157
+ }
158
+ return value === undefined ? definition : undefined;
159
+ };
160
+
161
+ export const reportInitialStatesProgress = (
162
+ count: number,
163
+ onProgress: ((progress: InitialStatesProgress) => void) | undefined,
164
+ ) => {
165
+ if (count > 1 && (count & (count - 1)) === 0) {
166
+ onProgress?.({ kind: "initial-states-progress", count });
167
+ }
168
+ };
169
+
170
+ // After SANY, TLC computes the constant definitions and warns once about each invariant that is a
171
+ // true constant formula, which it doesn't check.
172
+ export const reportStartup = (
173
+ specification: {
174
+ environment: Environment;
175
+ startupDefinitions: Definition[];
176
+ javaOverrides: JavaOverride[];
177
+ },
178
+ config: ModelConfig,
179
+ onProgress: CheckOptions["onProgress"],
180
+ ) => {
181
+ const environment = specification.environment;
182
+ const warned = new Set<string>();
183
+ environment.runtime.warn = (code, text) => {
184
+ if (warned.has(text)) return;
185
+ warned.add(text);
186
+ onProgress?.({ kind: "warning", code, text });
187
+ };
188
+ onProgress?.({ kind: "parsed" });
189
+ // TLC loads the classes of the modules before it computes the constant definitions.
190
+ specification.javaOverrides.forEach((override) =>
191
+ onProgress?.({ kind: "java-override", ...override }),
192
+ );
193
+ evaluateStartupDefinitions(specification.startupDefinitions, environment);
194
+ config.invariants.forEach((name) => {
195
+ if (!getConfigPredicate("invariant", name, environment)) {
196
+ onProgress?.({ kind: "constant-level-invariant", name });
197
+ }
198
+ });
199
+ };
200
+
201
+ const getInvariants = (names: string[], environment: Environment) => {
202
+ const analyzer = createLevelAnalyzer({
203
+ constants: new Set(environment.constants.keys()),
204
+ variables: new Set(environment.variables),
205
+ getDefinition: (name) => getDefinition(name, environment),
206
+ });
207
+ return names.flatMap((name) => {
208
+ const definition = getConfigPredicate("invariant", name, environment);
209
+ if (!definition) return [];
210
+ const levels = analyzer.analyzeDefinition(definition, new Map());
211
+ if (levels.level >= ACTION_LEVEL) {
212
+ const note =
213
+ levels.params.size === 0
214
+ ? ""
215
+ : "\nNote that a bug can cause TLC to incorrectly report this error.\nIf you believe your TLA+ or PlusCal specification to be correct,\nplease check if this bug described in LevelNode.java starting at line 590ff affects you.";
216
+ throw setExitCode(
217
+ new TlaConfigError(
218
+ `The invariant ${name} is not a state predicate (one with no primes or temporal operators).${note}`,
219
+ ),
220
+ EXIT_STATUS.safetyEvaluationFailure,
221
+ );
222
+ }
223
+ return [{ name, expression: createIdentifier(name), scope: undefined }];
224
+ });
225
+ };
226
+
227
+ const getConjuncts = (expression: Expression, environment: Environment): Expression[] => {
228
+ if (expression.kind === "And")
229
+ return expression.operands.flatMap((operand) => getConjuncts(operand, environment));
230
+ if (expression.kind === "Identifier" && !environment.constants.has(expression.name)) {
231
+ const definition = getDefinition(expression.name, environment);
232
+ if (definition?.kind === "Operator" && definition.params.length === 0) {
233
+ return getConjuncts(definition.body, environment);
234
+ }
235
+ }
236
+ return [expression];
237
+ };
238
+
239
+ const isConstantTrue = (item: ScopedExpression, environment: Environment, usage: string) => {
240
+ const conjunct = item.expression;
241
+ if (
242
+ conjunct.kind !== "Identifier" ||
243
+ getLevel(conjunct, item.scope, environment) > CONSTANT_LEVEL
244
+ ) {
245
+ return false;
246
+ }
247
+ const value = evaluate(conjunct, getContext(environment, undefined, undefined, item.scope));
248
+ if (value === false) {
249
+ throw new TlaConfigError(`The spec is trivially false because ${conjunct.name} is false.`);
250
+ }
251
+ if (value !== true) {
252
+ throw new TlaConfigError(
253
+ `The operator ${conjunct.name}, which equals ${formatValue(value)},\ncannot be used as a ${usage}`,
254
+ );
255
+ }
256
+ return true;
257
+ };
258
+
259
+ const getSpecification = (config: ModelConfig, environment: Environment): Specification => {
260
+ if (config.specification === undefined) {
261
+ const getOperator = (name: string | undefined, description: string) => {
262
+ if (name === undefined) return undefined;
263
+ getConfigDefinition(description, name, environment);
264
+ return createIdentifier(name);
265
+ };
266
+ return {
267
+ init: getOperator(config.init, "initial predicate"),
268
+ next: getOperator(config.next, "next state action"),
269
+ scope: undefined,
270
+ temporals: [],
271
+ };
272
+ }
273
+ if (config.init !== undefined || config.next !== undefined) {
274
+ throw new TlaConfigError(
275
+ "The configuration file cannot specify both INIT/NEXT and SPECIFICATION fields.",
276
+ );
277
+ }
278
+ const initConjuncts: ScopedExpression[] = [];
279
+ const nextActions: ScopedExpression[] = [];
280
+ const temporals: ScopedExpression[] = [];
281
+ const definition = getConfigOperator("name", config.specification, environment);
282
+ const value = getConstantValue(config.specification, definition, environment);
283
+ if (value !== undefined) {
284
+ throw new TlaConfigError(
285
+ `The value of ${config.specification} is equal to ${formatValue(value)}`,
286
+ );
287
+ }
288
+ expandTemporal(definition.body, undefined, environment, false).forEach((item) => {
289
+ const conjunct = item.expression;
290
+ if (isConstantTrue(item, environment, "spec")) return;
291
+ if (conjunct.kind === "UnboundedQuantifier" && conjunct.isTemporal) {
292
+ throw setExitCode(
293
+ new TlaConfigError(
294
+ "TLC does not support temporal existential, nor universal, quantification over state variables.",
295
+ ),
296
+ EXIT_STATUS.error,
297
+ );
298
+ }
299
+ if (conjunct.kind === "Always" && conjunct.expression.kind === "BoxAction") {
300
+ nextActions.push({ expression: conjunct.expression.action, scope: item.scope });
301
+ return;
302
+ }
303
+ if (
304
+ conjunct.kind === "Always" &&
305
+ getLevel(conjunct.expression, item.scope, environment) < ACTION_LEVEL
306
+ ) {
307
+ // TLC accepts the spec and fails when it builds the tableau of the temporal formulas.
308
+ throw setExitCode(
309
+ new TlaEvaluationError(
310
+ `TLC cannot handle the temporal formula ${describeRange(conjunct.expression)}`,
311
+ ),
312
+ EXIT_STATUS.error,
313
+ );
314
+ }
315
+ const level = getLevel(conjunct, item.scope, environment);
316
+ if (level === TEMPORAL_LEVEL) {
317
+ temporals.push(item);
318
+ return;
319
+ }
320
+ if (level === ACTION_LEVEL) {
321
+ throw new TlaConfigError(
322
+ `TLC cannot handle the action-level conjunct of the specification ${config.specification}`,
323
+ );
324
+ }
325
+ initConjuncts.push(item);
326
+ });
327
+ if (nextActions.length > 1) {
328
+ throw new TlaConfigError(
329
+ `The specification ${config.specification} must contain at most one [][Next]_vars`,
330
+ );
331
+ }
332
+ const items = [...initConjuncts, ...nextActions];
333
+ const getName = (index: number) => `$specification${index}`;
334
+ const scope = items.reduce<Scope | undefined>(
335
+ (parent, item, index) =>
336
+ item.scope === undefined
337
+ ? parent
338
+ : {
339
+ name: getName(index),
340
+ binding: {
341
+ kind: "Thunk",
342
+ expression: item.expression,
343
+ scope: item.scope,
344
+ state: undefined,
345
+ next: undefined,
346
+ cache: undefined,
347
+ isStreamed: false,
348
+ },
349
+ parent,
350
+ },
351
+ undefined,
352
+ );
353
+ const getReference = (item: ScopedExpression, index: number): Expression =>
354
+ item.scope === undefined
355
+ ? item.expression
356
+ : {
357
+ kind: "Identifier",
358
+ name: getName(index),
359
+ location: item.expression.location,
360
+ resolution: { kind: "Local" },
361
+ };
362
+ return {
363
+ init:
364
+ initConjuncts.length === 0
365
+ ? undefined
366
+ : { kind: "And", operands: initConjuncts.map(getReference), location: START },
367
+ next: nextActions.length === 0 ? undefined : getReference(nextActions[0], initConjuncts.length),
368
+ scope,
369
+ temporals,
370
+ };
371
+ };
372
+
373
+ const getProperties = (
374
+ config: ModelConfig,
375
+ environment: Environment,
376
+ onProgress: CheckOptions["onProgress"],
377
+ ): Properties => {
378
+ const properties: Properties = {
379
+ initialPredicates: [],
380
+ invariants: [],
381
+ actionProperties: [],
382
+ liveness: [],
383
+ };
384
+ config.properties.forEach((name) => {
385
+ const definition = getConfigPredicate("property", name, environment);
386
+ if (!definition) return;
387
+ // TLC checks a property that is a state formula only on the initial states, so it warns about
388
+ // one as it processes the property, before the constraints.
389
+ if (getLevel(definition.body, undefined, environment) === VARIABLE_LEVEL) {
390
+ onProgress?.({ kind: "state-level-property", name });
391
+ }
392
+ // TLC 1.7.4 expands a property as it does a specification, so it doesn't unroll one that
393
+ // quantifies over a constant set.
394
+ const isProperty = environment.runtime.version !== "1.7.4";
395
+ expandTemporal(definition.body, undefined, environment, isProperty).forEach((item) => {
396
+ const conjunct = item.expression;
397
+ if (isConstantTrue(item, environment, "property")) return;
398
+ const partName = item.name ?? name;
399
+ if (conjunct.kind === "Always" && conjunct.expression.kind === "BoxAction") {
400
+ properties.actionProperties.push({
401
+ name: partName,
402
+ box: conjunct.expression,
403
+ action: conjunct.expression.action,
404
+ subscript: conjunct.expression.subscript,
405
+ scope: item.scope,
406
+ });
407
+ return;
408
+ }
409
+ if (
410
+ conjunct.kind === "Always" &&
411
+ getLevel(conjunct.expression, item.scope, environment) <= VARIABLE_LEVEL
412
+ ) {
413
+ // TLC names the invariant by the operator the property asserts always holds, when it
414
+ // applies the operator to no arguments. The name of an operator another module defines
415
+ // resolves to its key, so the name comes from its definition.
416
+ const body = conjunct.expression;
417
+ const operator =
418
+ body.kind === "Identifier" && !isLocallyResolved(body)
419
+ ? getDefinition(body.name, environment)
420
+ : undefined;
421
+ properties.invariants.push({
422
+ name: operator?.name ?? (body.kind === "Identifier" ? body.name : partName),
423
+ expression: body,
424
+ scope: item.scope,
425
+ });
426
+ return;
427
+ }
428
+ const level = getLevel(conjunct, item.scope, environment);
429
+ if (level < ACTION_LEVEL) {
430
+ properties.initialPredicates.push({
431
+ name: partName,
432
+ expression: conjunct,
433
+ scope: item.scope,
434
+ });
435
+ return;
436
+ }
437
+ if (level === ACTION_LEVEL) {
438
+ throw new TlaConfigError(`The property ${name} is an action-level formula`);
439
+ }
440
+ properties.liveness.push({ name, expression: conjunct, scope: item.scope });
441
+ });
442
+ });
443
+ return properties;
444
+ };
445
+
446
+ const getNamedExpressions = (
447
+ kind: string,
448
+ names: string[],
449
+ environment: Environment,
450
+ ): NamedExpression[] =>
451
+ names.flatMap((name) =>
452
+ getConfigPredicate(kind, name, environment)
453
+ ? [{ name, expression: createIdentifier(name), scope: undefined }]
454
+ : [],
455
+ );
456
+
457
+ const getBodyRange = (name: string, environment: Environment) => {
458
+ const definition = getDefinition(name, environment);
459
+ return definition?.kind === "Operator" ? definition.bodyRange : undefined;
460
+ };
461
+
462
+ const getPossiblePredicates = (names: string[], environment: Environment) =>
463
+ names.map((name, index) => {
464
+ if (names.indexOf(name) !== index) {
465
+ throw new TlaConfigError(`_POSSIBLE lists ${name} more than once`);
466
+ }
467
+ getConfigDefinition("possible", name, environment);
468
+ const expression = createIdentifier(name);
469
+ if (getLevel(expression, undefined, environment) === TEMPORAL_LEVEL) {
470
+ throw new TlaConfigError(
471
+ `The possible of ${name} is equal to a temporal formula; only state- and action-level predicates are supported`,
472
+ );
473
+ }
474
+ return { name, expression, scope: undefined };
475
+ });
476
+
477
+ const getMembership = (
478
+ expression: Expression,
479
+ variables: number[] | undefined,
480
+ environment: Environment,
481
+ ): Membership | undefined => {
482
+ if (expression.kind !== "Apply" || expression.operator !== "\\in" || variables?.length !== 1)
483
+ return undefined;
484
+ const element = expression.args[0];
485
+ if (element.kind !== "Identifier" || isLocallyResolved(element)) return undefined;
486
+ return environment.variableIndex.get(element.name) === variables[0]
487
+ ? { variable: variables[0], set: expression.args[1] }
488
+ : undefined;
489
+ };
490
+
491
+ // TLC evaluates the body of an invariant that the configuration names.
492
+ const getPredicate = (expression: Expression, environment: Environment) => {
493
+ if (expression.kind !== "Identifier" || environment.constants.has(expression.name)) {
494
+ return expression;
495
+ }
496
+ const definition = getDefinition(expression.name, environment);
497
+ return definition?.kind === "Operator" && definition.params.length === 0
498
+ ? definition.body
499
+ : expression;
500
+ };
501
+
502
+ const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
503
+ named.flatMap((item) =>
504
+ getConjuncts(item.expression, environment).map((expression) => {
505
+ // A LET or an argument in the scope can read variables the expression doesn't name.
506
+ const variables =
507
+ item.scope === undefined ? getReadVariables(expression, environment) : undefined;
508
+ return {
509
+ name: item.name,
510
+ expression,
511
+ scope: item.scope,
512
+ variables,
513
+ membership: getMembership(expression, variables, environment),
514
+ predicate: getPredicate(item.expression, environment),
515
+ };
516
+ }),
517
+ );
518
+
519
+ const isUnchangedFor = (stateCheck: StateCheck, state: Value[], parent: Value[] | undefined) => {
520
+ const variables = stateCheck.variables;
521
+ if (!parent || !variables) return false;
522
+ for (let index = 0; index < variables.length; index++) {
523
+ if (state[variables[index]] !== parent[variables[index]]) return false;
524
+ }
525
+ return true;
526
+ };
527
+
528
+ const WIDE_CHARACTER = /[\u0100-\uffff]/;
529
+
530
+ const DESERIALIZERS = new Set(["JsonDeserialize", "ndJsonDeserialize"]);
531
+
532
+ const isWideConfigValue = (value: ConfigValue): boolean =>
533
+ value.kind === "String"
534
+ ? WIDE_CHARACTER.test(value.value)
535
+ : value.kind === "Set" && value.elements.some(isWideConfigValue);
536
+
537
+ const isWideExpression = (expression: Expression): boolean =>
538
+ (expression.kind === "String" && WIDE_CHARACTER.test(expression.value)) ||
539
+ (expression.kind === "Apply" && DESERIALIZERS.has(expression.operator)) ||
540
+ getChildren(expression).some(isWideExpression);
541
+
542
+ // TLC fingerprints a string by the low byte of each character, so it merges states whose
543
+ // strings differ only above U+00FF. Strings reach a state from literals, the config, or files.
544
+ const hasWideString = (config: ModelConfig, environment: Environment) =>
545
+ config.constants.some(
546
+ (constant) =>
547
+ isWideConfigValue(constant.value) || (constant.args ?? []).some(isWideConfigValue),
548
+ ) ||
549
+ [...environment.definitions.values()].some(
550
+ (definition) =>
551
+ isWideExpression(definition.body) ||
552
+ (definition.kind === "Function" &&
553
+ definition.bounds.some((bound) => isWideExpression(bound.set))),
554
+ );
555
+
556
+ interface Search {
557
+ properties: Properties;
558
+ spec: Specification;
559
+ getFingerprintState: (state: Value[]) => Value[];
560
+ getStoredFingerprints: (states: Value[][], fingerprintStates: Value[][]) => BigInt64Array;
561
+ getTlcOrder: () => number[];
562
+ isSymmetric: boolean;
563
+ // TLC drops a constraint that is a true constant formula.
564
+ isConstrained: boolean;
565
+ findViolatedInvariant: (state: Value[], parent?: Value[]) => StateCheck | undefined;
566
+ // The checks of a state that TLC evaluates when it replays the computation of the initial states
567
+ // or of the successors of a state, with an environment that records the call stack. The first
568
+ // returns the check that stops the replay, and the second false where TLC stops it.
569
+ // TLC fingerprints a replayed state that satisfies the constraints before it checks the rest.
570
+ checkReplayedInitialState: (
571
+ state: Value[],
572
+ tracing: Environment,
573
+ addFingerprint: () => void,
574
+ ) => Pick<InitialStateViolation, "status" | "name"> | undefined;
575
+ // Adding the fingerprint of a successor tells whether TLC had not seen it yet.
576
+ checkReplayedSuccessor: (
577
+ state: Value[],
578
+ next: Value[],
579
+ tracing: Environment,
580
+ addFingerprint: () => boolean,
581
+ ) => boolean;
582
+ satisfiesConstraints: (state: Value[], parent?: Value[]) => boolean;
583
+ findFailedInitialPredicate: (state: Value[]) => NamedExpression | undefined;
584
+ findViolatedActionProperty: (state: Value[], next: Value[]) => ActionProperty | undefined;
585
+ satisfiesActionConstraints: (state: Value[], next: Value[]) => boolean;
586
+ trackStatePossible: (state: Value[]) => void;
587
+ trackActionPossible: (state: Value[], next: Value[]) => void;
588
+ findUnwitnessedPossible: () => Postcondition | undefined;
589
+ // After a counterexample, TLC skips the postconditions when one of them is constant.
590
+ findPostconditionViolation: (isAfterViolation?: boolean) => Postcondition | undefined;
591
+ }
592
+
593
+ export const getContext = (
594
+ environment: Environment,
595
+ state: Value[] | undefined,
596
+ next: Value[] | undefined,
597
+ scope?: Scope,
598
+ ) => ({ environment, scope, state, next });
599
+
600
+ const holds = (expression: Expression, context: Context, description: string) =>
601
+ expectBoolean(evaluate(expression, context), description);
602
+
603
+ // TLC names a check that is not a boolean by the location of the predicate it evaluates.
604
+ const holdsLikeTlc = (
605
+ expression: Expression,
606
+ context: Context,
607
+ getMessage = getExpectedBoolean,
608
+ ) => {
609
+ const value = evaluate(expression, context);
610
+ if (typeof value !== "boolean") {
611
+ throw new TlaEvaluationError(getMessage(expression, context.environment));
612
+ }
613
+ return value;
614
+ };
615
+
616
+ const getExpectedBoolean = (expression: Expression, environment: Environment) => {
617
+ const definition =
618
+ expression.kind === "Identifier" ? getDefinition(expression.name, environment) : undefined;
619
+ const body = definition?.kind === "Operator" ? definition.body : expression;
620
+ const range = definition?.kind === "Operator" ? definition.bodyRange : undefined;
621
+ const location = range && body.kind !== "Number" ? formatRange(range) : describeNode(body);
622
+ return `TLC expected a boolean value, but did not find one. ${location}`;
623
+ };
624
+
625
+ // TLC evaluates the whole predicate of a check, which fails at a conjunct that isn't a boolean as
626
+ // the conjunction does.
627
+ const holdsAsConjunct = (check: StateCheck, context: Context) =>
628
+ holdsLikeTlc(check.expression, context, (expression, environment) => {
629
+ holdsLikeTlc(check.predicate, context);
630
+ return getExpectedBoolean(expression, environment);
631
+ });
632
+
633
+ const ignorePossible = () => {};
634
+
635
+ const trackPossible = (items: NamedExpression[], runtime: CheckerRuntime, context: Context) =>
636
+ items.forEach((item) => {
637
+ const count = runtime.possibleCounts.get(item.name) ?? 0;
638
+ const isWitnessed = holds(item.expression, context, `_POSSIBLE ${item.name}`);
639
+ runtime.possibleCounts.set(item.name, isWitnessed ? count + 1 : count);
640
+ });
641
+
642
+ const getConstantFailure = (
643
+ expression: Expression,
644
+ environment: Environment,
645
+ description: string,
646
+ ) => {
647
+ try {
648
+ return holds(expression, getContext(environment, undefined, undefined), description)
649
+ ? undefined
650
+ : { message: undefined };
651
+ } catch (error) {
652
+ if (error instanceof TlaEvaluationError) return { message: error.message };
653
+ throw error;
654
+ }
655
+ };
656
+
657
+ export const findAssumptionViolation = (
658
+ assumptions: Assumption[],
659
+ environment: Environment,
660
+ ): Omit<Violation, "loopStart"> | undefined => {
661
+ for (const assumption of assumptions.filter((candidate) => !candidate.isAxiom)) {
662
+ const failure = getConstantFailure(assumption.expression, environment, "an assumption");
663
+ if (failure) {
664
+ return { name: describeRange(assumption.expression), trace: [], message: failure.message };
665
+ }
666
+ }
667
+ return undefined;
668
+ };
669
+
670
+ export const createSearch = (
671
+ config: ModelConfig,
672
+ environment: Environment,
673
+ getVariableOrder: () => string[],
674
+ onProgress?: CheckOptions["onProgress"],
675
+ ): Search | undefined => {
676
+ const configInvariants = getInvariants(config.invariants, environment);
677
+ const spec = getSpecification(config, environment);
678
+ const properties = getProperties(config, environment, onProgress);
679
+ const invariants = getStateChecks([...configInvariants, ...properties.invariants], environment);
680
+ // The invariants TLC evaluates, each of which may have several conjuncts among the checks.
681
+ const invariantPredicates = [
682
+ ...new Map(invariants.map((invariant) => [invariant.predicate, invariant])).values(),
683
+ ];
684
+ const isCheckingBehaviors =
685
+ invariants.length > 0 ||
686
+ properties.actionProperties.length > 0 ||
687
+ properties.liveness.length > 0;
688
+ if (
689
+ spec.init === undefined &&
690
+ (isCheckingBehaviors ||
691
+ properties.initialPredicates.length > 0 ||
692
+ environment.variables.length > 0)
693
+ ) {
694
+ throw new TlaConfigError(
695
+ environment.runtime.version === "1.7.4"
696
+ ? MISSING_INIT_174
697
+ : "The configuration file did not specify the initial state predicate.",
698
+ );
699
+ }
700
+ if (spec.next === undefined && isCheckingBehaviors) {
701
+ throw new TlaConfigError("The configuration file did not specify the next state predicate.");
702
+ }
703
+ const constraints = getStateChecks(
704
+ getNamedExpressions("constraint", config.constraints, environment),
705
+ environment,
706
+ );
707
+ const actionConstraints = getNamedExpressions(
708
+ "action constraint",
709
+ config.actionConstraints,
710
+ environment,
711
+ );
712
+ if (config.rlReward !== undefined) getConfigOperator("rlreward", config.rlReward, environment);
713
+ if (config.periodic !== undefined) getConfigOperator("periodic", config.periodic, environment);
714
+ const possible = getPossiblePredicates(config.possible, environment);
715
+ if (environment.variables.length === 0) return undefined;
716
+ const symmetryGroup =
717
+ config.symmetry === undefined
718
+ ? undefined
719
+ : getSymmetryGroup(config.symmetry, environment, config.substitutions);
720
+ if (config.view !== undefined) getConfigOperator("view function", config.view, environment);
721
+ const view =
722
+ config.view === undefined
723
+ ? undefined
724
+ : { name: config.view, expression: createIdentifier(config.view), scope: undefined };
725
+ const actionProperties = properties.actionProperties.map((property) => {
726
+ const unchanged: Expression = {
727
+ kind: "Unchanged",
728
+ expression: property.subscript,
729
+ location: START,
730
+ };
731
+ return { ...property, unchanged };
732
+ });
733
+ const isActionPossible = (item: NamedExpression) =>
734
+ getLevel(item.expression, undefined, environment) >= ACTION_LEVEL;
735
+ const statePossible = possible.filter((item) => !isActionPossible(item));
736
+ const actionPossible = possible.filter(isActionPossible);
737
+ const runtime = environment.runtime;
738
+ const tlcOrder = { indices: undefined as number[] | undefined };
739
+ const getTlcOrder = () => {
740
+ if (tlcOrder.indices) return tlcOrder.indices;
741
+ const variableOrder = getVariableOrder();
742
+ const getTlcPosition = (index: number) => {
743
+ const position = variableOrder.indexOf(environment.variables[index]);
744
+ return position === -1 ? environment.variables.length : position;
745
+ };
746
+ tlcOrder.indices = environment.variables
747
+ .map((_, index) => index)
748
+ .sort((left, right) => getTlcPosition(left) - getTlcPosition(right));
749
+ return tlcOrder.indices;
750
+ };
751
+ const getViewValue = (expression: Expression, state: Value[]) =>
752
+ evaluate(expression, getContext(environment, state, undefined));
753
+ const getTlcStateFingerprint = (state: Value[]) => {
754
+ const indices = getTlcOrder();
755
+ const representative =
756
+ symmetryGroup === undefined ? state : getRepresentative(state, symmetryGroup, indices);
757
+ return getTlcFingerprint(
758
+ view === undefined
759
+ ? indices.map((index) => representative[index])
760
+ : [getViewValue(view.expression, representative)],
761
+ );
762
+ };
763
+ const isFingerprintedLikeTlc = hasWideString(config, environment);
764
+ runtime.getFingerprint = getTlcStateFingerprint;
765
+ const findUnwitnessedPossible = () => {
766
+ const unwitnessed = possible.find((item) => !runtime.possibleCounts.get(item.name));
767
+ if (!unwitnessed) return undefined;
768
+ const range = getBodyRange(unwitnessed.name, environment);
769
+ const location = range ? ` at ${formatRange(range)}` : "";
770
+ return {
771
+ name: unwitnessed.name,
772
+ code: MESSAGE_CODE.possibleUnwitnessed,
773
+ message: `The _POSSIBLE predicate ${unwitnessed.name}${location} was never witnessed.\nOthers may be unwitnessed too; only witnessed predicates appear with a\nnon-zero count in the record printed above.\nSee https://explain.tlapl.us/possible-conditions for additional details.`,
774
+ counts: prettyPrint(formatValue(getPossibleCounts(runtime), true)),
775
+ };
776
+ };
777
+ return {
778
+ properties,
779
+ spec,
780
+ isSymmetric: symmetryGroup !== undefined,
781
+ isConstrained: constraints.length > 0 || actionConstraints.length > 0,
782
+ getTlcOrder,
783
+ getStoredFingerprints: (states, fingerprintStates) => {
784
+ if (view !== undefined || isFingerprintedLikeTlc) {
785
+ return BigInt64Array.from(states, getTlcStateFingerprint);
786
+ }
787
+ const fingerprints = new BigInt64Array(fingerprintStates.length);
788
+ const fingerprint = createTlcFingerprinter(
789
+ getTlcOrder(),
790
+ new Int32Array(fingerprints.buffer),
791
+ );
792
+ fingerprintStates.forEach(fingerprint);
793
+ return fingerprints;
794
+ },
795
+ getFingerprintState: (state) => {
796
+ if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
797
+ // A representative in TLC's variable order is the one whose fingerprint TLC reports.
798
+ const representative =
799
+ symmetryGroup === undefined
800
+ ? state
801
+ : getRepresentative(state, symmetryGroup, getTlcOrder());
802
+ return view === undefined ? representative : [getViewValue(view.expression, representative)];
803
+ },
804
+ findViolatedInvariant: (state, parent) =>
805
+ invariants.find((invariant) => {
806
+ if (isUnchangedFor(invariant, state, parent)) return false;
807
+ try {
808
+ const context = getContext(environment, state, undefined, invariant.scope);
809
+ const membership = invariant.membership;
810
+ // The parent satisfies every invariant, so only the entries the step changed can fail.
811
+ return parent && membership
812
+ ? !isUpdatedElementOf(
813
+ state[membership.variable],
814
+ parent[membership.variable],
815
+ evaluate(membership.set, context),
816
+ )
817
+ : !holdsAsConjunct(invariant, context);
818
+ } catch (error) {
819
+ // TLC reports a failure only on a state after the initial states as an invariant failure.
820
+ if (!parent) throw error;
821
+ throw withHeadline(
822
+ setExitCode(error, EXIT_STATUS.safetyEvaluationFailure),
823
+ MESSAGE_CODE.invariantEvaluationFailed,
824
+ `Evaluating invariant ${invariant.name} failed.`,
825
+ );
826
+ }
827
+ }),
828
+ checkReplayedInitialState: (state, tracing, addFingerprint) => {
829
+ const holdsIn = (expression: Expression, scope: Scope | undefined) =>
830
+ holdsLikeTlc(expression, getContext(tracing, state, undefined, scope));
831
+ if (constraints.every((constraint) => holdsIn(constraint.predicate, constraint.scope))) {
832
+ addFingerprint();
833
+ }
834
+ const invariant = invariantPredicates.find((check) => !holdsIn(check.predicate, check.scope));
835
+ if (invariant) return { status: "invariant-violation", name: invariant.name };
836
+ const predicate = properties.initialPredicates.find(
837
+ (check) => !holdsIn(check.expression, check.scope),
838
+ );
839
+ return predicate && { status: "liveness-violation", name: predicate.name };
840
+ },
841
+ checkReplayedSuccessor: (state, next, tracing, addFingerprint) => {
842
+ // TLC evaluates the action constraints only on a state that satisfies the constraints.
843
+ const isInModel =
844
+ constraints.every((constraint) =>
845
+ holdsLikeTlc(
846
+ constraint.predicate,
847
+ getContext(tracing, next, undefined, constraint.scope),
848
+ ),
849
+ ) &&
850
+ actionConstraints.every((constraint) =>
851
+ holdsLikeTlc(constraint.expression, getContext(tracing, state, next, constraint.scope)),
852
+ );
853
+ // ModelChecker.doNext checks the invariants of a successor it has not seen, which includes
854
+ // one outside the model.
855
+ const isUnseen = isInModel ? addFingerprint() : true;
856
+ return (
857
+ (!isUnseen ||
858
+ invariantPredicates.every((invariant) =>
859
+ holdsLikeTlc(
860
+ invariant.predicate,
861
+ getContext(tracing, next, undefined, invariant.scope),
862
+ ),
863
+ )) &&
864
+ actionProperties.every((property) =>
865
+ holdsLikeTlc(property.box, getContext(tracing, state, next, property.scope)),
866
+ )
867
+ );
868
+ },
869
+ satisfiesConstraints: (state, parent) =>
870
+ constraints.every(
871
+ (constraint) =>
872
+ isUnchangedFor(constraint, state, parent) ||
873
+ holdsAsConjunct(constraint, getContext(environment, state, undefined)),
874
+ ),
875
+ findFailedInitialPredicate: (state) =>
876
+ properties.initialPredicates.find(
877
+ (predicate) =>
878
+ !holdsLikeTlc(
879
+ predicate.expression,
880
+ getContext(environment, state, undefined, predicate.scope),
881
+ ),
882
+ ),
883
+ findViolatedActionProperty: (state, next) =>
884
+ actionProperties.find((property) => {
885
+ try {
886
+ return (
887
+ !holdsLikeTlc(
888
+ property.action,
889
+ getContext(environment, state, next, property.scope),
890
+ () =>
891
+ `Attempted to evaluate an expression of form [A]_e, but A was not a boolean.\n${describeRange(property.box)}`,
892
+ ) &&
893
+ !holds(
894
+ property.unchanged,
895
+ getContext(environment, state, next, property.scope),
896
+ "a subscript",
897
+ )
898
+ );
899
+ } catch (error) {
900
+ throw withHeadline(
901
+ withNextStateExitCode(error),
902
+ MESSAGE_CODE.actionPropertyEvaluationFailed,
903
+ `Evaluating action property ${property.name} failed.`,
904
+ );
905
+ }
906
+ }),
907
+ satisfiesActionConstraints: (state, next) =>
908
+ actionConstraints.every((constraint) =>
909
+ holdsLikeTlc(
910
+ constraint.expression,
911
+ getContext(environment, state, next),
912
+ (expression) => `${UNEXPECTED_EXCEPTION}${getExpectedBoolean(expression, environment)}`,
913
+ ),
914
+ ),
915
+ trackStatePossible:
916
+ statePossible.length === 0
917
+ ? ignorePossible
918
+ : (state) =>
919
+ trackPossible(statePossible, runtime, getContext(environment, state, undefined)),
920
+ trackActionPossible:
921
+ actionPossible.length === 0
922
+ ? ignorePossible
923
+ : (state, next) =>
924
+ trackPossible(actionPossible, runtime, getContext(environment, state, next)),
925
+ findUnwitnessedPossible,
926
+ findPostconditionViolation: (isAfterViolation = false) => {
927
+ // TLC replaces a definition it computes when it starts by its value, and then rejects it as
928
+ // a postcondition before it checks any of them.
929
+ const constant = config.postconditions.find((name) => {
930
+ const definition = getDefinition(name, environment);
931
+ return definition !== undefined && environment.definitionValues.has(definition);
932
+ });
933
+ if (constant !== undefined) {
934
+ if (isAfterViolation) return undefined;
935
+ throw setExitCode(
936
+ new TlaEvaluationError(
937
+ `${UNEXPECTED_EXCEPTION}The post condition ${constant} cannot be a constant.`,
938
+ ),
939
+ EXIT_STATUS.error,
940
+ );
941
+ }
942
+ const unwitnessed = findUnwitnessedPossible();
943
+ if (unwitnessed) return unwitnessed;
944
+ for (const name of config.postconditions) {
945
+ const failure = getConstantFailure(createIdentifier(name), environment, "a postcondition");
946
+ if (!failure) continue;
947
+ const range = getBodyRange(name, environment);
948
+ const location = range ? ` at ${formatRange(range)}` : "";
949
+ return failure.message === undefined
950
+ ? {
951
+ name,
952
+ code: MESSAGE_CODE.postconditionFalse,
953
+ message: `Postcondition ${name}${location} is false.`,
954
+ }
955
+ : {
956
+ name,
957
+ code: MESSAGE_CODE.postconditionFailed,
958
+ message: `Evaluating postcondition ${name}${location} failed.\n${failure.message}`,
959
+ };
960
+ }
961
+ return undefined;
962
+ },
963
+ };
964
+ };
965
+
966
+ // TLC exits with the code of a standard module's failure only when the failure escapes the
967
+ // computation of next states. In every other phase, the phase decides the code.
968
+ export const withNextStateExitCode = (error: unknown) =>
969
+ error instanceof TlaModuleError ? setExitCode(error, error.exitCode) : error;