tla-ts 0.0.3 → 0.0.4-dev.1a3acf6

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 (381) hide show
  1. package/README.md +46 -115
  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 +194 -8
  8. package/dist/index.d.ts +194 -8
  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 +1377 -18
  23. package/dist/transfer.js +1377 -18
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +24 -11
  27. package/src/ast.ts +149 -8
  28. package/src/bags.ts +26 -30
  29. package/src/builtins.ts +45 -19
  30. package/src/bundled-modules.ts +3 -3
  31. package/src/check.ts +1182 -900
  32. package/src/cli/options.ts +109 -0
  33. package/src/cli/run.ts +63 -0
  34. package/src/cli/shared.ts +106 -0
  35. package/src/cli/tlapm.ts +374 -0
  36. package/src/cli/tlc.ts +941 -0
  37. package/src/cli/xml-exporter.ts +221 -0
  38. package/src/cli.ts +9 -2
  39. package/src/codegen.ts +112 -51
  40. package/src/config.ts +254 -181
  41. package/src/dependencies.ts +5 -7
  42. package/src/environment.ts +579 -184
  43. package/src/errors.ts +287 -4
  44. package/src/evaluate.ts +1095 -365
  45. package/src/exit-codes.ts +22 -43
  46. package/src/fingerprints.ts +49 -14
  47. package/src/index.ts +11 -0
  48. package/src/instances.ts +73 -60
  49. package/src/java-overrides.ts +183 -66
  50. package/src/json.ts +31 -36
  51. package/src/levels.ts +197 -54
  52. package/src/lexer.ts +127 -30
  53. package/src/liveness-checker.ts +894 -0
  54. package/src/liveness.ts +246 -596
  55. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  56. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  57. package/src/obligations/equality.ts +260 -0
  58. package/src/obligations/expression.ts +618 -0
  59. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  60. package/src/obligations/generate.ts +457 -0
  61. package/src/{obligations.ts → obligations/index.ts} +46 -32
  62. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  63. package/src/obligations/module.ts +445 -0
  64. package/src/obligations/normalize.ts +554 -0
  65. package/src/obligations/operators.ts +176 -0
  66. package/src/obligations/pragma.ts +195 -0
  67. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  68. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  69. package/src/obligations/regroup.ts +100 -0
  70. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  71. package/src/{obligation-source.ts → obligations/source.ts} +174 -216
  72. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  73. package/src/obligations/substitution.ts +261 -0
  74. package/src/obligations/temporal.ts +321 -0
  75. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  76. package/src/parallel-worker.ts +184 -235
  77. package/src/parallel.ts +156 -91
  78. package/src/parser.ts +490 -188
  79. package/src/pcal/ast.ts +755 -0
  80. package/src/pcal/parse.ts +1487 -0
  81. package/src/pcal/tokenize.ts +487 -0
  82. package/src/pcal/translate.ts +1151 -0
  83. package/src/pcal/validate.ts +444 -0
  84. package/src/prover/decide-pool.ts +95 -0
  85. package/src/prover/deciders.ts +33 -0
  86. package/src/prover/first-order.ts +175 -0
  87. package/src/prover/isabelle/LICENSE +36 -0
  88. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  89. package/src/prover/isabelle/decide.ts +44 -0
  90. package/src/prover/isabelle/encode.ts +445 -0
  91. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  92. package/src/prover/isabelle/isar/method.ts +367 -0
  93. package/src/prover/isabelle/isar/proof.ts +28 -0
  94. package/src/prover/isabelle/isar/statement.ts +57 -0
  95. package/src/prover/isabelle/isar/theory.ts +192 -0
  96. package/src/prover/isabelle/isar/type-check.ts +278 -0
  97. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  98. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  99. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  100. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  101. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  102. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  103. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  104. package/src/prover/isabelle/provers/classical.ts +389 -0
  105. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  106. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  107. package/src/prover/isabelle/pure/consts.ts +32 -0
  108. package/src/prover/isabelle/pure/conv.ts +79 -0
  109. package/src/prover/isabelle/pure/drule.ts +264 -0
  110. package/src/prover/isabelle/pure/envir.ts +331 -0
  111. package/src/prover/isabelle/pure/goal.ts +53 -0
  112. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  113. package/src/prover/isabelle/pure/list.ts +12 -0
  114. package/src/prover/isabelle/pure/logic.ts +330 -0
  115. package/src/prover/isabelle/pure/name.ts +98 -0
  116. package/src/prover/isabelle/pure/net.ts +215 -0
  117. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  118. package/src/prover/isabelle/pure/pattern.ts +631 -0
  119. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  120. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  121. package/src/prover/isabelle/pure/search.ts +68 -0
  122. package/src/prover/isabelle/pure/seq.ts +133 -0
  123. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  124. package/src/prover/isabelle/pure/table.ts +201 -0
  125. package/src/prover/isabelle/pure/tactic.ts +168 -0
  126. package/src/prover/isabelle/pure/tactical.ts +264 -0
  127. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  128. package/src/prover/isabelle/pure/term.ts +688 -0
  129. package/src/prover/isabelle/pure/thm.ts +783 -0
  130. package/src/prover/isabelle/pure/type.ts +121 -0
  131. package/src/prover/isabelle/pure/unify.ts +753 -0
  132. package/src/prover/isabelle/pure/variable.ts +25 -0
  133. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  134. package/src/prover/isabelle/tla/context.ts +74 -0
  135. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  136. package/src/prover/isabelle/tla/logic.ts +215 -0
  137. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  138. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  139. package/src/prover/ocaml.ts +22 -0
  140. package/src/prover/prep/action.ts +508 -0
  141. package/src/prover/prep/enabled-axioms.ts +189 -0
  142. package/src/prover/prep/fingerprint.ts +388 -0
  143. package/src/prover/prep/level-comparison.ts +529 -0
  144. package/src/prover/prep/md5.ts +60 -0
  145. package/src/prover/prep/methods.ts +221 -0
  146. package/src/prover/prep/normalize.ts +309 -0
  147. package/src/prover/prove-worker.ts +22 -0
  148. package/src/prover/prove.ts +492 -0
  149. package/src/prover/ptl/decide.ts +68 -0
  150. package/src/prover/ptl/encode.ts +244 -0
  151. package/src/prover/ptl/sat.ts +151 -0
  152. package/src/prover/ptl/tableau.ts +276 -0
  153. package/src/prover/smt/axioms.ts +209 -0
  154. package/src/prover/smt/context.ts +108 -0
  155. package/src/prover/smt/data.ts +636 -0
  156. package/src/prover/smt/encode.ts +275 -0
  157. package/src/prover/smt/extensionality.ts +65 -0
  158. package/src/prover/smt/flatten.ts +112 -0
  159. package/src/prover/smt/format.ts +154 -0
  160. package/src/prover/smt/instances.ts +181 -0
  161. package/src/prover/smt/rewrite.ts +766 -0
  162. package/src/prover/smt/solver/act-cache.ts +265 -0
  163. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  164. package/src/prover/smt/solver/array.ts +22 -0
  165. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  166. package/src/prover/smt/solver/ast-lt.ts +157 -0
  167. package/src/prover/smt/solver/ast-util.ts +91 -0
  168. package/src/prover/smt/solver/ast.ts +1315 -0
  169. package/src/prover/smt/solver/auf-solver.ts +572 -0
  170. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  171. package/src/prover/smt/solver/cg-table.ts +175 -0
  172. package/src/prover/smt/solver/clause.ts +276 -0
  173. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  174. package/src/prover/smt/solver/context.ts +1292 -0
  175. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  176. package/src/prover/smt/solver/der.ts +224 -0
  177. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  178. package/src/prover/smt/solver/e-matching.ts +659 -0
  179. package/src/prover/smt/solver/enode.ts +259 -0
  180. package/src/prover/smt/solver/expr-ref.ts +21 -0
  181. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  182. package/src/prover/smt/solver/fingerprints.ts +92 -0
  183. package/src/prover/smt/solver/flat-literals.ts +51 -0
  184. package/src/prover/smt/solver/goal.ts +138 -0
  185. package/src/prover/smt/solver/hash.ts +173 -0
  186. package/src/prover/smt/solver/hashtable.ts +166 -0
  187. package/src/prover/smt/solver/internalizer.ts +1381 -0
  188. package/src/prover/smt/solver/lbool.ts +5 -0
  189. package/src/prover/smt/solver/literal.ts +24 -0
  190. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  191. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  192. package/src/prover/smt/solver/lp/containers.ts +296 -0
  193. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  194. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  195. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  196. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  197. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  198. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  199. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  200. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  201. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  202. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  203. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  204. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  205. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  206. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  207. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  208. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  209. package/src/prover/smt/solver/lp/nex.ts +120 -0
  210. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  211. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  212. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  213. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  214. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  215. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  216. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  217. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  218. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  219. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  220. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  221. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  222. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  223. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  224. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  225. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  226. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  227. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  228. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  229. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  230. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  231. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  232. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  233. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  234. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  235. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  236. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  237. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  238. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  239. package/src/prover/smt/solver/model-checker.ts +347 -0
  240. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  241. package/src/prover/smt/solver/model-finder.ts +155 -0
  242. package/src/prover/smt/solver/model-generator.ts +97 -0
  243. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  244. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  245. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  246. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  247. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  248. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  249. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  250. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  251. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  252. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  253. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  254. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  255. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  256. package/src/prover/smt/solver/nnf.ts +469 -0
  257. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  258. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  259. package/src/prover/smt/solver/propagate-values.ts +83 -0
  260. package/src/prover/smt/solver/proto-model.ts +551 -0
  261. package/src/prover/smt/solver/pull-quant.ts +139 -0
  262. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  263. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  264. package/src/prover/smt/solver/qe-lite.ts +381 -0
  265. package/src/prover/smt/solver/qi-queue.ts +362 -0
  266. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  267. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  268. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  269. package/src/prover/smt/solver/random-gen.ts +10 -0
  270. package/src/prover/smt/solver/rational.ts +165 -0
  271. package/src/prover/smt/solver/ref-vector.ts +62 -0
  272. package/src/prover/smt/solver/relevancy.ts +247 -0
  273. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  274. package/src/prover/smt/solver/rewriter.ts +843 -0
  275. package/src/prover/smt/solver/rlimit.ts +79 -0
  276. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  277. package/src/prover/smt/solver/solver.ts +71 -0
  278. package/src/prover/smt/solver/sort.ts +35 -0
  279. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  280. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  281. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  282. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  283. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  284. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  285. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  286. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  287. package/src/prover/smt/solver/theory-lra.ts +56 -0
  288. package/src/prover/smt/solver/var-subst.ts +258 -0
  289. package/src/prover/smt/solver/z3-license.txt +10 -0
  290. package/src/prover/smt/table.ts +170 -0
  291. package/src/prover/tlapm/cache.ts +236 -0
  292. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  293. package/src/prover/tlapm/tlapm.ts +96 -0
  294. package/src/prover/tlaps-module.ts +510 -0
  295. package/src/prover/verdict.ts +13 -0
  296. package/src/prover/zenon/LICENSE +32 -0
  297. package/src/prover/zenon/check/check.ts +105 -0
  298. package/src/prover/zenon/check/definitions.ts +144 -0
  299. package/src/prover/zenon/check/equality.ts +182 -0
  300. package/src/prover/zenon/check/functions.ts +62 -0
  301. package/src/prover/zenon/check/keys.ts +125 -0
  302. package/src/prover/zenon/check/propositional.ts +104 -0
  303. package/src/prover/zenon/check/records.ts +188 -0
  304. package/src/prover/zenon/check/relations.ts +121 -0
  305. package/src/prover/zenon/check/rewrites.ts +224 -0
  306. package/src/prover/zenon/check/sets.ts +302 -0
  307. package/src/prover/zenon/check/terms.ts +127 -0
  308. package/src/prover/zenon/check/tla.ts +126 -0
  309. package/src/prover/zenon/decide.ts +107 -0
  310. package/src/prover/zenon/encode.ts +378 -0
  311. package/src/prover/zenon/eqrel.ts +300 -0
  312. package/src/prover/zenon/equality-rules.ts +435 -0
  313. package/src/prover/zenon/expr.ts +551 -0
  314. package/src/prover/zenon/index-table.ts +350 -0
  315. package/src/prover/zenon/isar-case.ts +513 -0
  316. package/src/prover/zenon/isar.ts +1249 -0
  317. package/src/prover/zenon/limits.ts +15 -0
  318. package/src/prover/zenon/llproof.ts +173 -0
  319. package/src/prover/zenon/mltoll.ts +1566 -0
  320. package/src/prover/zenon/node.ts +297 -0
  321. package/src/prover/zenon/ocaml.ts +169 -0
  322. package/src/prover/zenon/parse.ts +247 -0
  323. package/src/prover/zenon/phrase.ts +191 -0
  324. package/src/prover/zenon/proof.ts +198 -0
  325. package/src/prover/zenon/propositional-rules.ts +387 -0
  326. package/src/prover/zenon/rules.ts +94 -0
  327. package/src/prover/zenon/search.ts +288 -0
  328. package/src/prover/zenon/tla/functions.ts +151 -0
  329. package/src/prover/zenon/tla/llproof.ts +480 -0
  330. package/src/prover/zenon/tla/records.ts +225 -0
  331. package/src/prover/zenon/tla/rewrites.ts +447 -0
  332. package/src/prover/zenon/tla/sets.ts +304 -0
  333. package/src/prover/zenon/tla/terms.ts +162 -0
  334. package/src/prover/zenon/tla/tla.ts +506 -0
  335. package/src/randomization.ts +39 -27
  336. package/src/resolve.ts +1474 -426
  337. package/src/runtime.ts +25 -7
  338. package/src/sany/builtins.ts +147 -0
  339. package/src/sany/generator.ts +3111 -0
  340. package/src/sany/levels.ts +1205 -0
  341. package/src/sany/lexer.ts +544 -0
  342. package/src/sany/linter.ts +122 -0
  343. package/src/sany/modules.ts +1398 -0
  344. package/src/sany/nodes.ts +463 -0
  345. package/src/sany/parse-error.ts +2161 -0
  346. package/src/sany/report.ts +355 -0
  347. package/src/sany/selectors.ts +736 -0
  348. package/src/sany/source.ts +247 -0
  349. package/src/sany/xml.ts +1016 -0
  350. package/src/search.ts +969 -0
  351. package/src/spec-description.ts +66 -29
  352. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  353. package/src/standard-modules.ts +215 -164
  354. package/src/state-graph.ts +181 -0
  355. package/src/subexpressions.ts +231 -171
  356. package/src/substitution-levels.ts +40 -19
  357. package/src/successors.ts +253 -125
  358. package/src/symmetry.ts +194 -54
  359. package/src/tableau.ts +60 -32
  360. package/src/tlc/fingerprint.ts +214 -0
  361. package/src/{tlc-modules.ts → tlc/jar-data.ts} +4 -0
  362. package/src/tlc/messages.ts +441 -0
  363. package/src/{tlc-order.ts → tlc/order.ts} +84 -16
  364. package/src/{tlc-random.ts → tlc/random.ts} +30 -189
  365. package/src/tlc/replay.ts +659 -0
  366. package/src/{tlc-summary.ts → tlc/summary.ts} +20 -5
  367. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +59 -50
  368. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +63 -45
  369. package/src/tlc/version.ts +19 -0
  370. package/src/transfer.ts +44 -32
  371. package/src/values.ts +843 -241
  372. package/src/worker.ts +62 -0
  373. package/dist/parallel.cjs +0 -12
  374. package/dist/parallel.js +0 -12
  375. package/dist/run-cli.cjs +0 -28
  376. package/dist/run-cli.js +0 -28
  377. package/src/canonical.ts +0 -39
  378. package/src/cli-options.ts +0 -58
  379. package/src/obligation-expression.ts +0 -1060
  380. package/src/obligation-module.ts +0 -1042
  381. package/src/run-cli.ts +0 -478
package/src/liveness.ts CHANGED
@@ -1,14 +1,21 @@
1
- import type { Definition, Expression } from "./ast";
2
- import { TlaConfigError, TlaEvaluationError } from "./errors";
1
+ import { isLocallyResolved, type Bound, type Definition, type Expression } from "./ast";
3
2
  import {
4
- describeLocation,
3
+ createStackOverflowError,
4
+ TlaEvaluationError,
5
+ TlaStackOverflowError,
6
+ UNEXPECTED_EVAL_EXCEPTION,
7
+ } from "./errors";
8
+ import {
9
+ describeNode,
10
+ describeRange,
5
11
  bindDefinitions,
6
12
  bindOperatorArguments,
7
13
  evaluate,
8
14
  expectBoolean,
9
15
  forEachBinding,
16
+ forEachBoundElement,
17
+ getBoundElements,
10
18
  getDefinition,
11
- isLocallyResolved,
12
19
  lookupScope,
13
20
  resolveApplyOperator,
14
21
  resolveGlobalOperator,
@@ -19,78 +26,44 @@ import {
19
26
  type Thunk,
20
27
  } from "./evaluate";
21
28
  import { mapChildren } from "./instances";
22
- import { ACTION_LEVEL, TEMPORAL_LEVEL } from "./levels";
29
+ import { ACTION_LEVEL, CONSTANT_LEVEL, TEMPORAL_LEVEL, VARIABLE_LEVEL } from "./levels";
23
30
  import { isEnabled } from "./successors";
31
+ import { EXIT_STATUS, setExitCode } from "./exit-codes";
32
+ import { isEvalException } from "./tlc/messages";
24
33
  import {
25
34
  createBoolean,
26
35
  createJunction,
27
36
  createPair,
28
37
  createUnary,
29
38
  getLiveLevel,
30
- getSolutions,
31
- isFulfilling,
32
39
  type LiveEnabled,
33
40
  type LiveExpression,
34
- type Solution,
35
- type Tableau,
36
41
  } from "./tableau";
37
- import { isSameValue, type Value } from "./values";
42
+ import type { Value } from "./values";
38
43
 
39
44
  export interface ScopedExpression {
40
45
  expression: Expression;
41
46
  scope: Scope | undefined;
42
47
  }
43
48
 
44
- export interface TemporalProperty extends ScopedExpression {
45
- name: string;
46
- }
47
-
48
- export interface LiveSuccessor {
49
- index: number;
50
- state: Value[];
49
+ // A part of a temporal formula, with the name TLC gives the part when the formula is a property:
50
+ // a conjunct's location, or the name of the definition the part is the body of.
51
+ interface ExpandedExpression extends ScopedExpression {
52
+ name: string | undefined;
51
53
  }
52
54
 
53
- export interface Lasso {
54
- name: string;
55
- prefix: number[];
56
- cycle: number[];
57
- }
58
-
59
- interface SafetyViolation {
55
+ export interface TemporalProperty extends ScopedExpression {
60
56
  name: string;
61
- path: number[];
62
- }
63
-
64
- export interface LivenessChecker {
65
- addInitialState: (index: number, state: Value[]) => void;
66
- addState: (
67
- index: number,
68
- state: Value[],
69
- successors: LiveSuccessor[],
70
- ) => SafetyViolation | undefined;
71
- findViolation: () => Lasso | undefined;
72
- }
73
-
74
- interface Check {
75
- solution: Solution;
76
- stateResults: Uint8Array[];
77
- actionResults: Uint8Array[];
78
- consistency: Uint8Array[];
79
- product: BehaviorGraph | undefined;
80
- productNodes: Map<number, number>;
81
- nodesByState: Map<number, number[]>;
82
- }
83
-
84
- interface BehaviorGraph {
85
- states: number[];
86
- tableauNodes: number[];
87
- edges: number[][];
88
- initial: number[];
89
- parents: number[];
90
57
  }
91
58
 
92
59
  const MAXIMUM_EXPANSION_DEPTH = 100;
93
60
 
61
+ export const createTautologyError = () =>
62
+ setExitCode(
63
+ new TlaEvaluationError("Temporal formula is a tautology (its negation is unsatisfiable)."),
64
+ EXIT_STATUS.livenessEvaluationFailure,
65
+ );
66
+
94
67
  const TEMPORAL_OPERATORS = new Set(["~>", "-+->"]);
95
68
 
96
69
  const definitionLevels = new WeakMap<Definition, number>();
@@ -104,9 +77,10 @@ const getConstantContext = (environment: Environment, scope: Scope | undefined):
104
77
  next: undefined,
105
78
  });
106
79
 
107
- const createCannotHandleError = (expression: Expression) =>
80
+ // TLC adds the message of the error that stopped it, when it has one.
81
+ const createCannotHandleError = (expression: Expression, inner?: string) =>
108
82
  new TlaEvaluationError(
109
- `TLC cannot handle the temporal formula at ${describeLocation(expression)}`,
83
+ `TLC cannot handle the temporal formula ${describeRange(expression)}${inner === undefined ? "" : `:\n${inner}`}`,
110
84
  );
111
85
 
112
86
  export const getLevel = (
@@ -118,26 +92,31 @@ export const getLevel = (
118
92
  const getBindingLevel = (name: string) => {
119
93
  const binding = lookupScope(scope, name);
120
94
  if (!binding) return undefined;
121
- if (binding.kind === "Value") return 0;
95
+ if (binding.kind === "Value") return CONSTANT_LEVEL;
122
96
  if (binding.kind === "Thunk") return getLevel(binding.expression, binding.scope, environment);
123
97
  const operator = binding.operator;
124
- return operator.kind === "Closure" ? getLevel(operator.body, operator.scope, environment) : 0;
98
+ return operator.kind === "Closure"
99
+ ? getLevel(operator.body, operator.scope, environment)
100
+ : CONSTANT_LEVEL;
125
101
  };
126
102
  const getGlobalLevel = (name: string) => {
127
- if (environment.variableIndex.has(name)) return 1;
128
- if (environment.constants.has(name)) return 0;
103
+ if (environment.variableIndex.has(name)) return VARIABLE_LEVEL;
104
+ if (environment.constants.has(name)) return CONSTANT_LEVEL;
129
105
  const definition = getDefinition(name, environment);
130
106
  if (definition) return getDefinitionLevel(definition, environment);
131
107
  const builtin = environment.builtins.get(environment.substitutions.get(name) ?? name);
132
- return builtin ? (builtin.isStateLevel ? 1 : 0) : undefined;
108
+ if (!builtin) return undefined;
109
+ return builtin.isStateLevel && !builtin.isLevelConstant ? VARIABLE_LEVEL : CONSTANT_LEVEL;
133
110
  };
134
111
  const getNameLevel = (name: string, node: Expression) => {
135
- if (shadowed.has(name)) return 0;
136
- if (isLocallyResolved(node)) return getBindingLevel(name) ?? getGlobalLevel(name) ?? 0;
137
- return getGlobalLevel(name) ?? getBindingLevel(name) ?? 0;
112
+ if (shadowed.has(name)) return CONSTANT_LEVEL;
113
+ if (isLocallyResolved(node)) {
114
+ return getBindingLevel(name) ?? getGlobalLevel(name) ?? CONSTANT_LEVEL;
115
+ }
116
+ return getGlobalLevel(name) ?? getBindingLevel(name) ?? CONSTANT_LEVEL;
138
117
  };
139
118
  const getChildrenLevel = (node: Expression) => {
140
- const level = { value: 0 };
119
+ const level = { value: CONSTANT_LEVEL };
141
120
  mapChildren(node, (child, bound) => {
142
121
  level.value = Math.max(
143
122
  level.value,
@@ -159,7 +138,7 @@ export const getLevel = (
159
138
  case "AngleAction":
160
139
  return ACTION_LEVEL;
161
140
  case "Enabled":
162
- return 1;
141
+ return VARIABLE_LEVEL;
163
142
  case "Always":
164
143
  case "Eventually":
165
144
  case "WeakFairness":
@@ -193,21 +172,51 @@ const getDefinitionLevel = (definition: Definition, environment: Environment) =>
193
172
  return level;
194
173
  };
195
174
 
175
+ // TLC leaves a formula whose sets it fails to enumerate, and doesn't expect an EvalException.
176
+ const getUnrolledElements = (bounds: Bound[], context: Context) => {
177
+ try {
178
+ return getBoundElements(bounds, context);
179
+ } catch (error) {
180
+ if (!(error instanceof TlaEvaluationError)) throw error;
181
+ if (!isEvalException(error)) return undefined;
182
+ throw setExitCode(
183
+ new TlaEvaluationError(`${UNEXPECTED_EVAL_EXCEPTION}${error.message}`),
184
+ EXIT_STATUS.error,
185
+ );
186
+ }
187
+ };
188
+
196
189
  export const expandTemporal = (
197
190
  expression: Expression,
198
191
  scope: Scope | undefined,
199
192
  environment: Environment,
200
- isUnrollingForall: boolean,
193
+ // Whether TLC expands the formula as a property, which unrolls each \A over a constant set.
194
+ isProperty: boolean,
201
195
  expanding = new Set<Definition>(),
202
- ): ScopedExpression[] => {
196
+ // Whether the expansion entered the body of an instance's definition. Like TLC, it then no
197
+ // longer expands an operator applied to arguments.
198
+ isSubstituted = false,
199
+ name?: string,
200
+ ): ExpandedExpression[] => {
203
201
  const expand = (
204
202
  child: Expression,
205
203
  childScope: Scope | undefined,
204
+ childName = name,
206
205
  childExpanding = expanding,
207
- ): ScopedExpression[] =>
208
- expandTemporal(child, childScope, environment, isUnrollingForall, childExpanding);
206
+ definition?: Definition,
207
+ ): ExpandedExpression[] =>
208
+ expandTemporal(
209
+ child,
210
+ childScope,
211
+ environment,
212
+ isProperty,
213
+ childExpanding,
214
+ isSubstituted ||
215
+ (definition !== undefined && environment.substitutedDefinitions.has(definition)),
216
+ childName,
217
+ );
209
218
  if (expression.kind === "And") {
210
- return expression.operands.flatMap((operand) => expand(operand, scope));
219
+ return expression.operands.flatMap((operand) => expand(operand, scope, describeRange(operand)));
211
220
  }
212
221
  if (expression.kind === "Label") return expand(expression.body, scope);
213
222
  if (expression.kind === "Let") {
@@ -225,38 +234,62 @@ export const expandTemporal = (
225
234
  !binding &&
226
235
  definition?.kind === "Operator" &&
227
236
  definition.params.length === 0 &&
228
- getDefinitionLevel(definition, environment) > 0
237
+ getDefinitionLevel(definition, environment) > CONSTANT_LEVEL
229
238
  ) {
230
239
  if (expanding.has(definition)) {
231
- throw new TlaConfigError(`The definition of ${expression.name} refers to itself`);
240
+ throw createStackOverflowError();
232
241
  }
233
- return expand(definition.body, undefined, new Set([...expanding, definition]));
242
+ return expand(
243
+ definition.body,
244
+ undefined,
245
+ definition.name,
246
+ new Set([...expanding, definition]),
247
+ definition,
248
+ );
234
249
  }
235
250
  }
236
251
  const context = getConstantContext(environment, scope);
237
- if (expression.kind === "Apply" && getLevel(expression, scope, environment) === TEMPORAL_LEVEL) {
252
+ // TLC 1.7.4 never expands an operator applied to arguments. A property expands every one it
253
+ // applies, but a specification only the temporal ones.
254
+ if (
255
+ expression.kind === "Apply" &&
256
+ environment.runtime.version !== "1.7.4" &&
257
+ (isProperty || getLevel(expression, scope, environment) === TEMPORAL_LEVEL)
258
+ ) {
238
259
  const operator = resolveApplyOperator(expression, context);
239
260
  const definition = isLocallyResolved(expression)
240
261
  ? undefined
241
262
  : getDefinition(expression.operator, environment);
242
- if (operator?.kind === "Closure" && !definition?.isRecursive) {
243
- return expand(operator.body, bindOperatorArguments(operator, expression.args, context));
263
+ const isExpandable =
264
+ operator?.kind === "Closure" &&
265
+ operator.params.length === expression.args.length &&
266
+ !definition?.isRecursive &&
267
+ !isSubstituted;
268
+ if (isExpandable) {
269
+ return expand(
270
+ operator.body,
271
+ bindOperatorArguments(operator, expression.args, context),
272
+ expression.operator,
273
+ expanding,
274
+ definition,
275
+ );
244
276
  }
245
277
  }
246
278
  const isUnrolled =
247
- isUnrollingForall &&
279
+ isProperty &&
248
280
  expression.kind === "Forall" &&
249
- getLevel(expression.body, scope, environment) === TEMPORAL_LEVEL &&
250
- expression.bounds.every((bound) => getLevel(bound.set, scope, environment) === 0);
251
- if (isUnrolled) {
252
- const expanded: ScopedExpression[] = [];
253
- forEachBinding(expression.bounds, context, (boundScope) => {
254
- expanded.push(...expand(expression.body, boundScope));
281
+ expression.bounds.every((bound) => getLevel(bound.set, scope, environment) === CONSTANT_LEVEL);
282
+ const sets = isUnrolled ? getUnrolledElements(expression.bounds, context) : undefined;
283
+ if (isUnrolled && sets) {
284
+ const expanded: ExpandedExpression[] = [];
285
+ forEachBoundElement(expression.bounds, sets, scope, (boundScope) => {
286
+ expanded.push(...expand(expression.body, boundScope, describeRange(expression.body)));
255
287
  return false;
256
288
  });
289
+ if (expanded.length === 0) throw createTautologyError();
257
290
  return expanded;
258
291
  }
259
- return [{ expression, scope }];
292
+ return [{ expression, scope, name }];
260
293
  };
261
294
 
262
295
  const bindLetDefinitions = (
@@ -271,34 +304,30 @@ const bindLetDefinitions = (
271
304
  return bound;
272
305
  };
273
306
 
274
- const createAngleAction = (action: Expression, subscript: Expression): Expression => ({
275
- kind: "AngleAction",
276
- action,
277
- subscript,
278
- location: action.location,
279
- });
280
-
281
- const toLiveExpression = (
307
+ export const toLiveExpression = (
282
308
  root: Expression,
283
309
  rootScope: Scope | undefined,
284
310
  environment: Environment,
285
311
  ): LiveExpression => {
312
+ const is174 = environment.runtime.version === "1.7.4";
286
313
  const toAtom = (
287
314
  expression: Expression,
288
315
  scope: Scope | undefined,
289
316
  level: number,
290
317
  ): LiveExpression => {
291
- const atomLevel = level === 0 ? getLevel(expression, scope, environment) : level;
292
- if (atomLevel === 0) {
318
+ // TLC after 1.7.4 bounds the level of a formula whose parts are constant by the formula's own.
319
+ const atomLevel =
320
+ level === CONSTANT_LEVEL && !is174 ? getLevel(expression, scope, environment) : level;
321
+ if (atomLevel === CONSTANT_LEVEL) {
293
322
  const value = evaluate(expression, getConstantContext(environment, scope));
294
323
  if (typeof value !== "boolean") {
295
324
  throw new TlaEvaluationError(
296
- `TLC expected a boolean in the temporal formula at ${describeLocation(expression)}`,
325
+ `TLC expected a boolean value, but did not find one. ${describeNode(expression)}`,
297
326
  );
298
327
  }
299
328
  return createBoolean(value);
300
329
  }
301
- if (atomLevel === 1) return { kind: "State", expression, scope };
330
+ if (atomLevel === VARIABLE_LEVEL) return { kind: "State", expression, scope };
302
331
  return { kind: "Action", expression, unchanged: undefined, scope };
303
332
  };
304
333
 
@@ -311,9 +340,7 @@ const toLiveExpression = (
311
340
  scope: Scope | undefined,
312
341
  ) => {
313
342
  if (expansion.depth >= MAXIMUM_EXPANSION_DEPTH) {
314
- throw new TlaEvaluationError(
315
- `TLC overflowed the stack while expanding the temporal formula at ${describeLocation(expression)}`,
316
- );
343
+ throw createStackOverflowError();
317
344
  }
318
345
  expansion.depth++;
319
346
  const result = convert(body, bodyScope);
@@ -333,7 +360,9 @@ const toLiveExpression = (
333
360
  ? lookupScope(scope, name)
334
361
  : undefined;
335
362
  if (binding?.kind === "Thunk" && definitionThunks.has(binding)) {
336
- return expand(binding.expression, binding.scope, expression, scope);
363
+ return expandCall(expression, () =>
364
+ expand(binding.expression, binding.scope, expression, scope),
365
+ );
337
366
  }
338
367
  const operator =
339
368
  binding?.kind === "Operator"
@@ -345,32 +374,104 @@ const toLiveExpression = (
345
374
  : resolveGlobalOperator(name, environment);
346
375
  if (operator?.kind !== "Closure") throw createCannotHandleError(expression);
347
376
  const args = expression.kind === "Apply" ? expression.args : [];
348
- return expand(operator.body, bindOperatorArguments(operator, args, context), expression, scope);
377
+ const isRecursive =
378
+ !isLocallyResolved(expression) && getDefinition(name, environment)?.isRecursive === true;
379
+ return expandCall(
380
+ expression,
381
+ () => {
382
+ // TLC 1.7.4 evaluates the arguments of an operator it expands.
383
+ if (is174) {
384
+ args
385
+ .filter((arg) => arg.kind !== "Lambda" && arg.kind !== "OperatorReference")
386
+ .forEach((arg) => evaluate(arg, context));
387
+ }
388
+ return expand(
389
+ operator.body,
390
+ bindOperatorArguments(operator, args, context),
391
+ expression,
392
+ scope,
393
+ );
394
+ },
395
+ isRecursive,
396
+ );
397
+ };
398
+
399
+ // TLC takes an application of an operator whose expansion fails for a formula it can't handle,
400
+ // except that TLC after 1.7.4 fails as the expansion of a recursive operator does.
401
+ const expandCall = (
402
+ expression: Expression,
403
+ expandBody: () => LiveExpression,
404
+ isRecursive = false,
405
+ ) => {
406
+ try {
407
+ return expandBody();
408
+ } catch (error) {
409
+ const isRethrown = error instanceof TlaStackOverflowError || (isRecursive && !is174);
410
+ if (!(error instanceof TlaEvaluationError) || isRethrown) throw error;
411
+ throw createCannotHandleError(expression);
412
+ }
349
413
  };
350
414
 
351
415
  const convertQuantifier = (
352
416
  expression: Expression & { kind: "Forall" | "Exists" },
353
417
  scope: Scope | undefined,
354
418
  ) => {
419
+ const level = getLevel(expression, scope, environment);
355
420
  const isConstant = expression.bounds.every(
356
- (bound) => getLevel(bound.set, scope, environment) === 0,
421
+ (bound) => getLevel(bound.set, scope, environment) === CONSTANT_LEVEL,
357
422
  );
358
- if (!isConstant) throw createCannotHandleError(expression);
423
+ if (!isConstant) {
424
+ if (level <= ACTION_LEVEL) return toAtom(expression, scope, level);
425
+ throw createCannotHandleError(expression);
426
+ }
359
427
  const operands: LiveExpression[] = [];
360
- forEachBinding(expression.bounds, getConstantContext(environment, scope), (boundScope) => {
361
- operands.push(convert(expression.body, boundScope));
362
- return false;
363
- });
364
428
  const isForall = expression.kind === "Forall";
429
+ // TLC takes a quantified formula whose body fails for one it can't handle, and under \A it adds
430
+ // the message of a failure that isn't an EvalException.
431
+ try {
432
+ forEachBinding(expression.bounds, getConstantContext(environment, scope), (boundScope) => {
433
+ operands.push(convert(expression.body, boundScope));
434
+ return false;
435
+ });
436
+ } catch (error) {
437
+ if (!(error instanceof TlaEvaluationError) || error instanceof TlaStackOverflowError) {
438
+ throw error;
439
+ }
440
+ if (level <= ACTION_LEVEL) return toAtom(expression, scope, level);
441
+ throw createCannotHandleError(
442
+ expression,
443
+ isForall && !isEvalException(error) ? error.message : undefined,
444
+ );
445
+ }
365
446
  if (operands.length === 0) return createBoolean(isForall);
366
- const result = createJunction(isForall ? "And" : "Or", operands);
367
- const level = getLiveLevel(result);
368
- return level > ACTION_LEVEL ? result : toAtom(expression, scope, level);
447
+ return toWhole(expression, scope, createJunction(isForall ? "And" : "Or", operands));
369
448
  };
370
449
 
450
+ // TLC takes a formula whose translated parts are below temporal level whole, at their level.
451
+ const toWhole = (expression: Expression, scope: Scope | undefined, parts: LiveExpression) => {
452
+ const level = getLiveLevel(parts);
453
+ return level > ACTION_LEVEL ? parts : toAtom(expression, scope, level);
454
+ };
455
+
456
+ // The formulas below temporal level whose parts TLC's Liveness.astToLive translates, as one
457
+ // that is constant, such as a quantifier over the empty set, can make the formula constant.
458
+ const isTranslatedWhole = (expression: Expression) =>
459
+ expression.kind === "Label" ||
460
+ expression.kind === "Let" ||
461
+ expression.kind === "And" ||
462
+ expression.kind === "Or" ||
463
+ expression.kind === "Forall" ||
464
+ expression.kind === "Exists" ||
465
+ expression.kind === "If" ||
466
+ (expression.kind === "Apply" &&
467
+ ((expression.operator === "~" && !isLocallyResolved(expression)) ||
468
+ expression.operator === "=>"));
469
+
371
470
  const convert = (expression: Expression, scope: Scope | undefined): LiveExpression => {
372
471
  const level = getLevel(expression, scope, environment);
373
- if (level <= ACTION_LEVEL) return toAtom(expression, scope, level);
472
+ if (level <= ACTION_LEVEL && !isTranslatedWhole(expression)) {
473
+ return toAtom(expression, scope, level);
474
+ }
374
475
  switch (expression.kind) {
375
476
  case "Label":
376
477
  return convert(expression.body, scope);
@@ -391,38 +492,51 @@ const toLiveExpression = (
391
492
  );
392
493
  }
393
494
  if (expression.operator === "~" && !isLocallyResolved(expression)) {
394
- return createUnary("Not", convert(args[0], scope));
495
+ return toWhole(expression, scope, createUnary("Not", convert(args[0], scope)));
395
496
  }
396
497
  if (expression.operator === "=>") {
397
- return createPair(
398
- "Or",
399
- createUnary("Not", convert(args[0], scope)),
400
- convert(args[1], scope),
498
+ return toWhole(
499
+ expression,
500
+ scope,
501
+ createPair("Or", createUnary("Not", convert(args[0], scope)), convert(args[1], scope)),
401
502
  );
402
503
  }
403
504
  return convertCall(expression, scope);
404
505
  }
405
506
  case "And":
406
507
  case "Or":
407
- return createJunction(
408
- expression.kind,
409
- expression.operands.map((operand) => convert(operand, scope)),
508
+ return toWhole(
509
+ expression,
510
+ scope,
511
+ createJunction(
512
+ expression.kind,
513
+ expression.operands.map((operand) => convert(operand, scope)),
514
+ ),
410
515
  );
411
516
  case "Forall":
412
517
  case "Exists":
413
518
  return convertQuantifier(expression, scope);
414
519
  case "If": {
415
- if (getLevel(expression.condition, scope, environment) === 0) {
520
+ // TLC 1.7.4 translates both branches whatever the guard.
521
+ if (!is174 && getLevel(expression.condition, scope, environment) === CONSTANT_LEVEL) {
416
522
  const condition = evaluate(expression.condition, getConstantContext(environment, scope));
417
523
  if (typeof condition === "boolean") {
418
524
  return convert(condition ? expression.consequent : expression.alternative, scope);
419
525
  }
420
526
  }
421
527
  const condition = convert(expression.condition, scope);
422
- return createPair(
423
- "Or",
424
- createPair("And", condition, convert(expression.consequent, scope)),
425
- createPair("And", createUnary("Not", condition), convert(expression.alternative, scope)),
528
+ return toWhole(
529
+ expression,
530
+ scope,
531
+ createPair(
532
+ "Or",
533
+ createPair("And", condition, convert(expression.consequent, scope)),
534
+ createPair(
535
+ "And",
536
+ createUnary("Not", condition),
537
+ convert(expression.alternative, scope),
538
+ ),
539
+ ),
426
540
  );
427
541
  }
428
542
  case "Always":
@@ -430,7 +544,12 @@ const toLiveExpression = (
430
544
  return createUnary(expression.kind, convert(expression.expression, scope));
431
545
  case "WeakFairness":
432
546
  case "StrongFairness": {
433
- const step = createAngleAction(expression.action, expression.subscript);
547
+ const step: Expression = {
548
+ kind: "AngleAction",
549
+ action: expression.action,
550
+ subscript: expression.subscript,
551
+ location: expression.action.location,
552
+ };
434
553
  const enabled: LiveEnabled = { kind: "Enabled", step: expression.enabled ?? step, scope };
435
554
  const disabled = createUnary("Not", enabled);
436
555
  const taken: LiveExpression = {
@@ -464,7 +583,7 @@ const toLiveExpression = (
464
583
  return convert(root, rootScope);
465
584
  };
466
585
 
467
- const evaluateLive = (
586
+ export const evaluateLive = (
468
587
  expression: LiveExpression,
469
588
  state: Value[],
470
589
  next: Value[] | undefined,
@@ -512,7 +631,7 @@ const evaluateLive = (
512
631
  }
513
632
  };
514
633
 
515
- const evaluateOnLasso = (
634
+ export const evaluateOnLasso = (
516
635
  expression: LiveExpression,
517
636
  path: Value[][],
518
637
  cycleStart: number,
@@ -547,472 +666,3 @@ const evaluateOnLasso = (
547
666
  );
548
667
  }
549
668
  };
550
-
551
- const liveKeys = new WeakMap<LiveExpression, string>();
552
-
553
- const atomCount = { value: 0 };
554
-
555
- const getLiveKey = (expression: LiveExpression): string => {
556
- const cached = liveKeys.get(expression);
557
- if (cached !== undefined) return cached;
558
- const key =
559
- expression.kind === "Boolean"
560
- ? String(expression.value)
561
- : "body" in expression
562
- ? `${expression.kind}(${getLiveKey(expression.body)})`
563
- : "operands" in expression
564
- ? `${expression.kind}(${expression.operands.map(getLiveKey).join(",")})`
565
- : `${expression.kind}#${atomCount.value++}`;
566
- liveKeys.set(expression, key);
567
- return key;
568
- };
569
-
570
- const isSameState = (left: Value[], right: Value[]) =>
571
- left.every((value, position) => isSameValue(value, right[position]));
572
-
573
- const getStronglyConnectedComponents = (
574
- nodeCount: number,
575
- getSuccessors: (node: number) => number[],
576
- visit: (component: number[], successors: (node: number) => number[]) => boolean,
577
- ) => {
578
- const order = new Int32Array(nodeCount).fill(-1);
579
- const lowLink = new Int32Array(nodeCount);
580
- const onStack = new Uint8Array(nodeCount);
581
- const stack: number[] = [];
582
- const counter = { value: 0 };
583
- const successorCache = new Map<number, number[]>();
584
- const getCachedSuccessors = (node: number) => {
585
- const cached = successorCache.get(node);
586
- if (cached) return cached;
587
- const successors = getSuccessors(node);
588
- successorCache.set(node, successors);
589
- return successors;
590
- };
591
- for (let root = 0; root < nodeCount; root++) {
592
- if (order[root] !== -1) continue;
593
- const frames: { node: number; position: number }[] = [];
594
- const open = (node: number) => {
595
- order[node] = counter.value;
596
- lowLink[node] = counter.value++;
597
- stack.push(node);
598
- onStack[node] = 1;
599
- frames.push({ node, position: 0 });
600
- };
601
- open(root);
602
- while (frames.length > 0) {
603
- const frame = frames[frames.length - 1];
604
- const successors = getCachedSuccessors(frame.node);
605
- if (frame.position < successors.length) {
606
- const target = successors[frame.position++];
607
- if (order[target] === -1) open(target);
608
- else if (onStack[target])
609
- lowLink[frame.node] = Math.min(lowLink[frame.node], order[target]);
610
- continue;
611
- }
612
- frames.pop();
613
- const parent = frames[frames.length - 1];
614
- if (parent) lowLink[parent.node] = Math.min(lowLink[parent.node], lowLink[frame.node]);
615
- if (lowLink[frame.node] !== order[frame.node]) continue;
616
- const component: number[] = [];
617
- while (true) {
618
- const member = stack.pop();
619
- if (member === undefined) break;
620
- onStack[member] = 0;
621
- component.push(member);
622
- if (member === frame.node) break;
623
- }
624
- const isFound = visit(component, getCachedSuccessors);
625
- component.forEach((member) => successorCache.delete(member));
626
- if (isFound) return;
627
- }
628
- }
629
- };
630
-
631
- const getShortestPath = (
632
- from: number,
633
- to: number,
634
- members: Set<number>,
635
- getSuccessors: (node: number) => number[],
636
- ) => {
637
- if (from === to) return [from];
638
- const parents = new Map<number, number>([[from, -1]]);
639
- const queue = [from];
640
- for (let position = 0; position < queue.length; position++) {
641
- for (const target of getSuccessors(queue[position])) {
642
- if (parents.has(target) || !members.has(target)) continue;
643
- parents.set(target, queue[position]);
644
- if (target === to) {
645
- const path: number[] = [];
646
- for (let node = to; node !== -1; node = parents.get(node) ?? -1) path.push(node);
647
- return path.reverse();
648
- }
649
- queue.push(target);
650
- }
651
- }
652
- return [from];
653
- };
654
-
655
- const removeRepeats = (path: number[]) =>
656
- path.filter((node, position) => position === 0 || path[position - 1] !== node);
657
-
658
- export const createLivenessChecker = (
659
- properties: TemporalProperty[],
660
- temporals: ScopedExpression[],
661
- environment: Environment,
662
- ): LivenessChecker | undefined => {
663
- if (properties.length === 0) return undefined;
664
- const fairness = temporals.map((item) =>
665
- toLiveExpression(item.expression, item.scope, environment),
666
- );
667
- const negations = properties.map((property) =>
668
- createUnary("Not", toLiveExpression(property.expression, property.scope, environment)),
669
- );
670
- const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
671
- const formula =
672
- fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
673
- const solutions = getSolutions(formula);
674
- if (solutions.length === 0) {
675
- throw new TlaEvaluationError("Temporal formula is a tautology (its negation is unsatisfiable)");
676
- }
677
- const checks = solutions.map((solution): Check => ({
678
- solution,
679
- stateResults: [],
680
- actionResults: [],
681
- consistency: [],
682
- product: solution.tableau && {
683
- states: [],
684
- tableauNodes: [],
685
- edges: [],
686
- initial: [],
687
- parents: [],
688
- },
689
- productNodes: new Map(),
690
- nodesByState: new Map(),
691
- }));
692
- const actionKeys = new Map<string, number>();
693
- const actionIds = checks.map((check) =>
694
- check.solution.actionChecks.map((predicate) => {
695
- const key = getLiveKey(predicate);
696
- const known = actionKeys.get(key);
697
- if (known !== undefined) return known;
698
- actionKeys.set(key, actionKeys.size);
699
- return actionKeys.size - 1;
700
- }),
701
- );
702
- const states: Value[][] = [];
703
- const targets: number[][] = [];
704
- const edgeStates: Value[][][] = [];
705
- const initial: number[] = [];
706
-
707
- const isConsistent = (
708
- predicates: LiveExpression[],
709
- state: Value[],
710
- cache: Map<LiveExpression, boolean>,
711
- ) =>
712
- predicates.every((predicate) => evaluateLive(predicate, state, undefined, environment, cache));
713
-
714
- const getProductNode = (
715
- check: Check,
716
- product: BehaviorGraph,
717
- state: number,
718
- tableauNode: number,
719
- parent: number,
720
- ) => {
721
- const key = state * (check.solution.tableau?.nodes.length ?? 1) + tableauNode;
722
- const existing = check.productNodes.get(key);
723
- if (existing !== undefined) return { node: existing, isNew: false };
724
- const node = product.states.length;
725
- check.productNodes.set(key, node);
726
- product.states.push(state);
727
- product.tableauNodes.push(tableauNode);
728
- product.edges.push([]);
729
- product.parents.push(parent);
730
- const siblings = check.nodesByState.get(state);
731
- if (siblings) siblings.push(node);
732
- else check.nodesByState.set(state, [node]);
733
- return { node, isNew: true };
734
- };
735
-
736
- const getAttribution = (path: number[], cycleStart: number) => {
737
- const lasso = path.map((state) => states[state]);
738
- return (
739
- properties.find(
740
- (_, position) =>
741
- !evaluateOnLasso(negations[position].body, lasso, cycleStart, 0, environment),
742
- ) ?? properties[0]
743
- ).name;
744
- };
745
-
746
- const expandProduct = (check: Check, product: BehaviorGraph, tableau: Tableau, state: number) => {
747
- const hasEmptyModel = check.solution.models.some(
748
- (model) =>
749
- model.eventuallyAlways.length === 0 &&
750
- model.infinitelyOftenStates.length === 0 &&
751
- model.infinitelyOftenActions.length === 0,
752
- );
753
- const nodeCount = tableau.nodes.length;
754
- const pending = (check.nodesByState.get(state) ?? []).map((node) => ({ node, isDone: false }));
755
- while (pending.length > 0) {
756
- const item = pending.pop();
757
- if (!item) break;
758
- const source = product.states[item.node];
759
- const successors = tableau.nodes[product.tableauNodes[item.node]].successors;
760
- const isAccepted =
761
- item.isDone &&
762
- hasEmptyModel &&
763
- successors.some((successor) => {
764
- const node = tableau.nodes[successor];
765
- return node.particle.length === 0 && node.successors.every((next) => next === successor);
766
- });
767
- if (isAccepted) {
768
- const path = removeRepeats(
769
- getPrefix(product, item.node).map((node) => product.states[node]),
770
- );
771
- return { name: getAttribution(path, path.length - 1), path };
772
- }
773
- const consistency = check.consistency[source];
774
- targets[source].forEach((target, edgeIndex) => {
775
- for (const successor of successors) {
776
- if (!consistency[edgeIndex * nodeCount + successor]) continue;
777
- const created = getProductNode(check, product, target, successor, item.node);
778
- product.edges[item.node].push(created.node, edgeIndex);
779
- if (created.isNew && targets[target] !== undefined) {
780
- pending.push({ node: created.node, isDone: true });
781
- }
782
- }
783
- });
784
- }
785
- return undefined;
786
- };
787
-
788
- const addInitialState = (index: number, state: Value[]) => {
789
- initial.push(index);
790
- states[index] = state;
791
- for (const check of checks) {
792
- const tableau = check.solution.tableau;
793
- const product = check.product;
794
- if (!tableau || !product) continue;
795
- const cache = new Map<LiveExpression, boolean>();
796
- for (let node = 0; node < tableau.initialCount; node++) {
797
- if (!isConsistent(tableau.nodes[node].statePredicates, state, cache)) continue;
798
- product.initial.push(getProductNode(check, product, index, node, -1).node);
799
- }
800
- }
801
- };
802
-
803
- const addState = (index: number, state: Value[], successors: LiveSuccessor[]) => {
804
- environment.runtime.setLivenessSource(index);
805
- states[index] = state;
806
- const edges: LiveSuccessor[] = [];
807
- const edgesByTarget = new Map<number, LiveSuccessor[]>();
808
- for (const successor of [...successors, { index, state }]) {
809
- const sameTarget = edgesByTarget.get(successor.index);
810
- const isDuplicate =
811
- sameTarget !== undefined &&
812
- (successor.index < index ||
813
- sameTarget.some((edge) => isSameState(edge.state, successor.state)));
814
- if (isDuplicate) continue;
815
- edges.push(successor);
816
- if (sameTarget) sameTarget.push(successor);
817
- else edgesByTarget.set(successor.index, [successor]);
818
- }
819
- targets[index] = edges.map((edge) => edge.index);
820
- edgeStates[index] = edges.map((edge) => edge.state);
821
- const stateCache = new Map<LiveExpression, boolean>();
822
- const successorCaches = edges.map(() => new Map<LiveExpression, boolean>());
823
- for (const check of checks) {
824
- const solution = check.solution;
825
- check.stateResults[index] = Uint8Array.from(solution.stateChecks, (predicate) =>
826
- evaluateLive(predicate, state, undefined, environment, stateCache) ? 1 : 0,
827
- );
828
- const tableau = solution.tableau;
829
- const product = check.product;
830
- if (!tableau || !product) continue;
831
- const nodeCount = tableau.nodes.length;
832
- const consistency = new Uint8Array(edges.length * nodeCount);
833
- edges.forEach((edge, edgeIndex) => {
834
- tableau.nodes.forEach((node, nodeIndex) => {
835
- const isTrue = isConsistent(node.statePredicates, edge.state, successorCaches[edgeIndex]);
836
- consistency[edgeIndex * nodeCount + nodeIndex] = isTrue ? 1 : 0;
837
- });
838
- });
839
- check.consistency[index] = consistency;
840
- const accepted = expandProduct(check, product, tableau, index);
841
- if (accepted) return accepted;
842
- }
843
- return undefined;
844
- };
845
-
846
- const computeActionResults = (source: number) => {
847
- environment.runtime.setLivenessSource(source);
848
- const state = states[source];
849
- const successors = edgeStates[source];
850
- const values = successors.map(() => new Int8Array(actionKeys.size).fill(-1));
851
- checks.forEach((check, checkIndex) => {
852
- const solution = check.solution;
853
- const ids = actionIds[checkIndex];
854
- const stateResults = check.stateResults[source];
855
- const stateCache = new Map(
856
- solution.stateChecks.map((predicate, position) => [
857
- predicate,
858
- stateResults[position] === 1,
859
- ]),
860
- );
861
- const actionCount = solution.actionChecks.length;
862
- const actions = new Uint8Array(successors.length * actionCount);
863
- successors.forEach((successor, edgeIndex) => {
864
- const known = values[edgeIndex];
865
- for (let position = 0; position < actionCount; position++) {
866
- const actionId = ids[position];
867
- if (known[actionId] === -1) {
868
- const predicate = solution.actionChecks[position];
869
- known[actionId] = evaluateLive(predicate, state, successor, environment, stateCache)
870
- ? 1
871
- : 0;
872
- }
873
- actions[edgeIndex * actionCount + position] = known[actionId];
874
- }
875
- });
876
- check.actionResults[source] = actions;
877
- });
878
- };
879
-
880
- const getActionResults = (check: Check, source: number) => {
881
- if (check.actionResults[source] === undefined) computeActionResults(source);
882
- return check.actionResults[source];
883
- };
884
-
885
- const getGraph = (check: Check): BehaviorGraph =>
886
- check.product ?? {
887
- states: states.map((_, index) => index),
888
- tableauNodes: states.map(() => -1),
889
- edges: Array.from({ length: states.length }, (_, index) =>
890
- (targets[index] ?? []).flatMap((target, edgeIndex) => [target, edgeIndex]),
891
- ),
892
- initial,
893
- parents: [],
894
- };
895
-
896
- const getPrefix = (graph: BehaviorGraph, entry: number) => {
897
- if (graph.parents.length > 0) {
898
- const path: number[] = [];
899
- for (let node = entry; node !== -1; node = graph.parents[node]) path.push(node);
900
- return path.reverse();
901
- }
902
- const parents = new Map<number, number>(graph.initial.map((node) => [node, -1]));
903
- const queue = [...graph.initial];
904
- for (let position = 0; position < queue.length && !parents.has(entry); position++) {
905
- const edges = graph.edges[queue[position]];
906
- for (let offset = 0; offset < edges.length; offset += 2) {
907
- if (parents.has(edges[offset])) continue;
908
- parents.set(edges[offset], queue[position]);
909
- queue.push(edges[offset]);
910
- }
911
- }
912
- const path: number[] = [];
913
- for (let node = entry; node !== -1; node = parents.get(node) ?? -1) path.push(node);
914
- return path.reverse();
915
- };
916
-
917
- const findInCheck = (check: Check): Lasso | undefined => {
918
- const solution = check.solution;
919
- const tableau = solution.tableau;
920
- const graph = getGraph(check);
921
- const actionCount = solution.actionChecks.length;
922
- const getAction = (node: number, edgeIndex: number, position: number) =>
923
- getActionResults(check, graph.states[node])[edgeIndex * actionCount + position] === 1;
924
- for (const model of solution.models) {
925
- const isAllowed = (node: number, edgeIndex: number) =>
926
- model.eventuallyAlways.every((position) => getAction(node, edgeIndex, position));
927
- const getSuccessors = (node: number) => {
928
- const edges = graph.edges[node];
929
- const successors: number[] = [];
930
- for (let offset = 0; offset < edges.length; offset += 2) {
931
- if (isAllowed(node, edges[offset + 1])) successors.push(edges[offset]);
932
- }
933
- return successors;
934
- };
935
- const lasso = { value: undefined as Lasso | undefined };
936
- getStronglyConnectedComponents(
937
- graph.states.length,
938
- getSuccessors,
939
- (component, successors) => {
940
- const members = new Set(component);
941
- if (component.length === 1 && !successors(component[0]).includes(component[0]))
942
- return false;
943
- const stateWitnesses = model.infinitelyOftenStates.map((position) =>
944
- component.find((node) => check.stateResults[graph.states[node]][position] === 1),
945
- );
946
- const actionWitnesses = model.infinitelyOftenActions.map((position) => {
947
- for (const node of component) {
948
- const edges = graph.edges[node];
949
- for (let offset = 0; offset < edges.length; offset += 2) {
950
- const isWitness =
951
- members.has(edges[offset]) &&
952
- isAllowed(node, edges[offset + 1]) &&
953
- getAction(node, edges[offset + 1], position);
954
- if (isWitness) return [node, edges[offset]];
955
- }
956
- }
957
- return undefined;
958
- });
959
- const promiseWitnesses = solution.promises.map((promise) =>
960
- component.find(
961
- (node) =>
962
- tableau !== undefined &&
963
- isFulfilling(tableau.nodes[graph.tableauNodes[node]].particle, promise),
964
- ),
965
- );
966
- const isViolation =
967
- stateWitnesses.every((witness) => witness !== undefined) &&
968
- actionWitnesses.every((witness) => witness !== undefined) &&
969
- promiseWitnesses.every((witness) => witness !== undefined);
970
- if (!isViolation) return false;
971
- const entry = component[component.length - 1];
972
- const waypoints = [
973
- ...stateWitnesses.flatMap((witness) => witness ?? []),
974
- ...actionWitnesses.flatMap((witness) => witness ?? []),
975
- ...promiseWitnesses.flatMap((witness) => witness ?? []),
976
- ];
977
- const cycle = [entry];
978
- for (const waypoint of waypoints) {
979
- cycle.push(
980
- ...getShortestPath(cycle[cycle.length - 1], waypoint, members, successors).slice(1),
981
- );
982
- }
983
- if (cycle.length === 1 && !successors(entry).includes(entry)) {
984
- cycle.push(successors(entry).find((node) => members.has(node)) ?? entry);
985
- }
986
- const closing = getShortestPath(cycle[cycle.length - 1], entry, members, successors);
987
- cycle.push(...closing.slice(1, -1));
988
- const prefix = removeRepeats(getPrefix(graph, entry).map((node) => graph.states[node]));
989
- const cycleStates = removeRepeats(cycle.map((node) => graph.states[node]));
990
- if (cycleStates.length > 1 && cycleStates[cycleStates.length - 1] === cycleStates[0]) {
991
- cycleStates.pop();
992
- }
993
- prefix.pop();
994
- lasso.value = {
995
- name: getAttribution([...prefix, ...cycleStates], prefix.length),
996
- prefix,
997
- cycle: cycleStates,
998
- };
999
- return true;
1000
- },
1001
- );
1002
- if (lasso.value) return lasso.value;
1003
- }
1004
- return undefined;
1005
- };
1006
-
1007
- return {
1008
- addInitialState,
1009
- addState,
1010
- findViolation: () => {
1011
- for (const check of checks) {
1012
- const lasso = findInCheck(check);
1013
- if (lasso) return lasso;
1014
- }
1015
- return undefined;
1016
- },
1017
- };
1018
- };