tla-ts 0.0.9 → 0.0.10-dev.63a6693bd

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 (400) hide show
  1. package/README.md +29 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +29 -29
  5. package/dist/deciders.js +42 -42
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +106 -10
  8. package/dist/index.d.ts +106 -10
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +117 -37
  15. package/dist/prove.js +116 -36
  16. package/dist/run.cjs +143 -31
  17. package/dist/run.js +143 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +129 -104
  21. package/dist/transfer.js +129 -104
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +3 -1
  25. package/src/ast.ts +48 -62
  26. package/src/bags.ts +99 -102
  27. package/src/builtins.ts +28 -75
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check-failure.ts +116 -0
  30. package/src/check-trace.ts +282 -0
  31. package/src/check.ts +599 -754
  32. package/src/cli/options.ts +12 -32
  33. package/src/cli/run.ts +0 -2
  34. package/src/cli/runtime-invariants.ts +136 -0
  35. package/src/cli/shared.ts +19 -12
  36. package/src/cli/tlapm.ts +14 -25
  37. package/src/cli/tlc-arguments.ts +652 -0
  38. package/src/cli/tlc-output.ts +687 -0
  39. package/src/cli/tlc-usage.ts +361 -0
  40. package/src/cli/tlc.ts +309 -658
  41. package/src/cli/typescript.ts +23 -0
  42. package/src/cli/xml-exporter.ts +27 -49
  43. package/src/cli.ts +0 -1
  44. package/src/codegen.ts +196 -74
  45. package/src/config.ts +140 -109
  46. package/src/coverage.ts +830 -0
  47. package/src/dependencies.ts +14 -53
  48. package/src/dfid.ts +618 -0
  49. package/src/environment-config.ts +315 -0
  50. package/src/environment.ts +169 -335
  51. package/src/errors.ts +71 -55
  52. package/src/evaluate.ts +598 -340
  53. package/src/exit-codes.ts +37 -3
  54. package/src/fingerprints.ts +75 -11
  55. package/src/index.ts +3 -0
  56. package/src/instances.ts +126 -21
  57. package/src/java-hash.ts +7 -0
  58. package/src/java-overrides.ts +4 -19
  59. package/src/json-reader.ts +455 -0
  60. package/src/json.ts +252 -139
  61. package/src/levels.ts +46 -58
  62. package/src/lexer.ts +80 -100
  63. package/src/liveness-checker.ts +103 -153
  64. package/src/liveness.ts +150 -109
  65. package/src/obligations/action.ts +8 -39
  66. package/src/obligations/anonymize.ts +88 -82
  67. package/src/obligations/equality.ts +1 -1
  68. package/src/obligations/expression.ts +20 -21
  69. package/src/obligations/format.ts +1 -9
  70. package/src/obligations/generate.ts +46 -49
  71. package/src/obligations/index.ts +2 -13
  72. package/src/obligations/levels.ts +4 -8
  73. package/src/obligations/module.ts +28 -53
  74. package/src/obligations/normalize.ts +7 -25
  75. package/src/obligations/operators.ts +1 -2
  76. package/src/obligations/pragma.ts +1 -10
  77. package/src/obligations/printer.ts +47 -46
  78. package/src/obligations/proof.ts +1 -5
  79. package/src/obligations/regroup.ts +1 -4
  80. package/src/obligations/simplify.ts +42 -58
  81. package/src/obligations/source.ts +48 -78
  82. package/src/obligations/subexpression.ts +5 -11
  83. package/src/obligations/substitution.ts +1 -3
  84. package/src/obligations/temporal.ts +13 -19
  85. package/src/obligations/tuples.ts +3 -9
  86. package/src/parallel-worker.ts +30 -60
  87. package/src/parallel.ts +57 -71
  88. package/src/parser.ts +584 -316
  89. package/src/pcal/ast.ts +53 -86
  90. package/src/pcal/parse.ts +144 -219
  91. package/src/pcal/tokenize.ts +91 -131
  92. package/src/pcal/translate.ts +83 -130
  93. package/src/pcal/validate.ts +48 -68
  94. package/src/pretty-print.ts +7 -8
  95. package/src/prover/decide-pool.ts +8 -13
  96. package/src/prover/deciders.ts +3 -7
  97. package/src/prover/first-order.ts +0 -11
  98. package/src/prover/isabelle/decide.ts +0 -6
  99. package/src/prover/isabelle/encode.ts +11 -23
  100. package/src/prover/isabelle/isar/inner-syntax.ts +114 -115
  101. package/src/prover/isabelle/isar/method.ts +29 -53
  102. package/src/prover/isabelle/isar/proof.ts +1 -10
  103. package/src/prover/isabelle/isar/statement.ts +1 -6
  104. package/src/prover/isabelle/isar/theory.ts +26 -36
  105. package/src/prover/isabelle/isar/type-check.ts +17 -31
  106. package/src/prover/isabelle/provers/blast/blast.ts +17 -104
  107. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  108. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  109. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  110. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  111. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  112. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  113. package/src/prover/isabelle/provers/classical.ts +14 -42
  114. package/src/prover/isabelle/provers/hypsubst.ts +28 -51
  115. package/src/prover/isabelle/pure/bicompose.ts +25 -38
  116. package/src/prover/isabelle/pure/consts.ts +1 -7
  117. package/src/prover/isabelle/pure/conv.ts +3 -17
  118. package/src/prover/isabelle/pure/drule.ts +33 -42
  119. package/src/prover/isabelle/pure/envir.ts +3 -52
  120. package/src/prover/isabelle/pure/goal.ts +1 -7
  121. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  122. package/src/prover/isabelle/pure/list.ts +0 -3
  123. package/src/prover/isabelle/pure/logic.ts +2 -15
  124. package/src/prover/isabelle/pure/name.ts +2 -9
  125. package/src/prover/isabelle/pure/net.ts +3 -59
  126. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  127. package/src/prover/isabelle/pure/pattern.ts +2 -19
  128. package/src/prover/isabelle/pure/raw-simplifier.ts +17 -62
  129. package/src/prover/isabelle/pure/rewriter.ts +31 -67
  130. package/src/prover/isabelle/pure/search.ts +3 -10
  131. package/src/prover/isabelle/pure/seq.ts +1 -10
  132. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  133. package/src/prover/isabelle/pure/table.ts +3 -32
  134. package/src/prover/isabelle/pure/tactic.ts +12 -22
  135. package/src/prover/isabelle/pure/tactical.ts +48 -47
  136. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  137. package/src/prover/isabelle/pure/term.ts +2 -43
  138. package/src/prover/isabelle/pure/thm.ts +27 -47
  139. package/src/prover/isabelle/pure/type.ts +2 -15
  140. package/src/prover/isabelle/pure/unify.ts +20 -30
  141. package/src/prover/isabelle/pure/variable.ts +3 -7
  142. package/src/prover/isabelle/tla/classical-setup.ts +17 -24
  143. package/src/prover/isabelle/tla/context.ts +15 -18
  144. package/src/prover/isabelle/tla/logic.ts +14 -32
  145. package/src/prover/isabelle/tla/simpdata.ts +46 -43
  146. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  147. package/src/prover/ocaml.ts +0 -6
  148. package/src/prover/prep/action.ts +14 -54
  149. package/src/prover/prep/enabled-axioms.ts +12 -19
  150. package/src/prover/prep/fingerprint.ts +2 -21
  151. package/src/prover/prep/level-comparison.ts +8 -12
  152. package/src/prover/prep/md5.ts +0 -2
  153. package/src/prover/prep/methods.ts +33 -39
  154. package/src/prover/prep/normalize.ts +4 -28
  155. package/src/prover/prove-worker.ts +0 -2
  156. package/src/prover/prove.ts +87 -100
  157. package/src/prover/ptl/decide.ts +7 -12
  158. package/src/prover/ptl/encode.ts +14 -36
  159. package/src/prover/ptl/sat.ts +24 -32
  160. package/src/prover/ptl/tableau.ts +12 -26
  161. package/src/prover/smt/axioms.ts +0 -7
  162. package/src/prover/smt/context.ts +20 -28
  163. package/src/prover/smt/data.ts +433 -424
  164. package/src/prover/smt/encode.ts +43 -52
  165. package/src/prover/smt/extensionality.ts +0 -10
  166. package/src/prover/smt/flatten.ts +3 -22
  167. package/src/prover/smt/format.ts +5 -10
  168. package/src/prover/smt/instances.ts +0 -10
  169. package/src/prover/smt/rewrite.ts +663 -667
  170. package/src/prover/smt/solver/act-cache.ts +0 -15
  171. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  172. package/src/prover/smt/solver/array.ts +1 -3
  173. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  174. package/src/prover/smt/solver/ast-lt.ts +1 -11
  175. package/src/prover/smt/solver/ast-util.ts +1 -6
  176. package/src/prover/smt/solver/ast.ts +1 -165
  177. package/src/prover/smt/solver/auf-solver.ts +8 -44
  178. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  179. package/src/prover/smt/solver/cg-table.ts +1 -18
  180. package/src/prover/smt/solver/clause.ts +1 -27
  181. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  182. package/src/prover/smt/solver/context.ts +7 -64
  183. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  184. package/src/prover/smt/solver/der.ts +2 -21
  185. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  186. package/src/prover/smt/solver/e-matching.ts +4 -35
  187. package/src/prover/smt/solver/enode.ts +1 -21
  188. package/src/prover/smt/solver/expr-ref.ts +1 -5
  189. package/src/prover/smt/solver/expr-safe-replace.ts +1 -6
  190. package/src/prover/smt/solver/fingerprints.ts +1 -12
  191. package/src/prover/smt/solver/flat-literals.ts +1 -9
  192. package/src/prover/smt/solver/goal.ts +2 -14
  193. package/src/prover/smt/solver/hash.ts +0 -8
  194. package/src/prover/smt/solver/hashtable.ts +1 -12
  195. package/src/prover/smt/solver/internalizer.ts +7 -100
  196. package/src/prover/smt/solver/lbool.ts +1 -2
  197. package/src/prover/smt/solver/literal.ts +0 -3
  198. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  199. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  200. package/src/prover/smt/solver/lp/containers.ts +12 -30
  201. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  202. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  203. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  204. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  205. package/src/prover/smt/solver/lp/dioph-eq.ts +9 -102
  206. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  207. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  208. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  209. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  210. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  211. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  212. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  213. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  214. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  215. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  216. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  217. package/src/prover/smt/solver/lp/nex.ts +1 -6
  218. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  220. package/src/prover/smt/solver/lp/nla-core.ts +36 -135
  221. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  222. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  223. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  224. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  225. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  226. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  227. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  228. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  229. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  230. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  231. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  232. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  233. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  234. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  235. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  236. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  237. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  238. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  239. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  240. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  241. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  242. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  243. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  244. package/src/prover/smt/solver/mam-compiler.ts +18 -58
  245. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  246. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  247. package/src/prover/smt/solver/model-checker.ts +3 -37
  248. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  249. package/src/prover/smt/solver/model-finder.ts +15 -32
  250. package/src/prover/smt/solver/model-generator.ts +1 -12
  251. package/src/prover/smt/solver/model-macro-solver.ts +23 -88
  252. package/src/prover/smt/solver/nlsat/algebraic.ts +63 -159
  253. package/src/prover/smt/solver/nlsat/atoms.ts +25 -23
  254. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  255. package/src/prover/smt/solver/nlsat/explain.ts +10 -69
  256. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  257. package/src/prover/smt/solver/nlsat/levelwise.ts +49 -135
  258. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  259. package/src/prover/smt/solver/nlsat/polynomial.ts +29 -159
  260. package/src/prover/smt/solver/nlsat/solver.ts +18 -90
  261. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  262. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +2 -45
  263. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  264. package/src/prover/smt/solver/nnf.ts +3 -38
  265. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  266. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  267. package/src/prover/smt/solver/propagate-values.ts +1 -10
  268. package/src/prover/smt/solver/proto-model.ts +3 -52
  269. package/src/prover/smt/solver/pull-quant.ts +1 -12
  270. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  271. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  272. package/src/prover/smt/solver/qe-lite.ts +3 -33
  273. package/src/prover/smt/solver/qi-queue.ts +1 -16
  274. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  275. package/src/prover/smt/solver/quantifier-analyzer.ts +27 -47
  276. package/src/prover/smt/solver/quantifier-manager.ts +2 -13
  277. package/src/prover/smt/solver/random-gen.ts +1 -2
  278. package/src/prover/smt/solver/rational.ts +1 -8
  279. package/src/prover/smt/solver/ref-vector.ts +1 -6
  280. package/src/prover/smt/solver/relevancy.ts +2 -15
  281. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  282. package/src/prover/smt/solver/rewriter.ts +3 -85
  283. package/src/prover/smt/solver/rlimit.ts +2 -20
  284. package/src/prover/smt/solver/smtlib-parser.ts +80 -131
  285. package/src/prover/smt/solver/solver.ts +23 -34
  286. package/src/prover/smt/solver/sort.ts +1 -5
  287. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  288. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  289. package/src/prover/smt/solver/theory-lra-bounds.ts +1 -7
  290. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  291. package/src/prover/smt/solver/theory-lra-internalize.ts +6 -43
  292. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  293. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  294. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  295. package/src/prover/smt/solver/theory-lra.ts +1 -8
  296. package/src/prover/smt/solver/var-subst.ts +2 -26
  297. package/src/prover/smt/table.ts +0 -8
  298. package/src/prover/tlapm/cache.ts +45 -40
  299. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  300. package/src/prover/tlapm/tlapm.ts +21 -20
  301. package/src/prover/verdict.ts +7 -2
  302. package/src/prover/zenon/check/check.ts +1 -11
  303. package/src/prover/zenon/check/definitions.ts +5 -15
  304. package/src/prover/zenon/check/equality.ts +0 -8
  305. package/src/prover/zenon/check/functions.ts +0 -4
  306. package/src/prover/zenon/check/keys.ts +0 -7
  307. package/src/prover/zenon/check/propositional.ts +0 -3
  308. package/src/prover/zenon/check/records.ts +1 -6
  309. package/src/prover/zenon/check/relations.ts +2 -14
  310. package/src/prover/zenon/check/rewrites.ts +2 -21
  311. package/src/prover/zenon/check/sets.ts +40 -61
  312. package/src/prover/zenon/check/terms.ts +1 -19
  313. package/src/prover/zenon/check/tla.ts +0 -6
  314. package/src/prover/zenon/decide.ts +0 -12
  315. package/src/prover/zenon/encode.ts +1 -8
  316. package/src/prover/zenon/eqrel.ts +2 -13
  317. package/src/prover/zenon/equality-rules.ts +0 -4
  318. package/src/prover/zenon/expr.ts +8 -26
  319. package/src/prover/zenon/index-table.ts +26 -57
  320. package/src/prover/zenon/isar-case.ts +9 -19
  321. package/src/prover/zenon/isar.ts +36 -64
  322. package/src/prover/zenon/limits.ts +0 -4
  323. package/src/prover/zenon/llproof.ts +2 -20
  324. package/src/prover/zenon/mltoll.ts +66 -104
  325. package/src/prover/zenon/node.ts +1 -11
  326. package/src/prover/zenon/ocaml.ts +1 -17
  327. package/src/prover/zenon/parse.ts +4 -12
  328. package/src/prover/zenon/phrase.ts +1 -11
  329. package/src/prover/zenon/proof.ts +0 -9
  330. package/src/prover/zenon/propositional-rules.ts +0 -5
  331. package/src/prover/zenon/rules.ts +2 -6
  332. package/src/prover/zenon/search.ts +5 -31
  333. package/src/prover/zenon/tla/functions.ts +59 -31
  334. package/src/prover/zenon/tla/llproof.ts +67 -76
  335. package/src/prover/zenon/tla/records.ts +57 -33
  336. package/src/prover/zenon/tla/rewrites.ts +12 -19
  337. package/src/prover/zenon/tla/sets.ts +83 -53
  338. package/src/prover/zenon/tla/terms.ts +0 -6
  339. package/src/prover/zenon/tla/tla.ts +66 -64
  340. package/src/randomization.ts +81 -35
  341. package/src/resolve.ts +67 -184
  342. package/src/runtime.ts +22 -22
  343. package/src/sany/builtins.ts +2 -5
  344. package/src/sany/generation.ts +394 -0
  345. package/src/sany/generator-def-entries.ts +210 -0
  346. package/src/sany/generator-definitions.ts +686 -0
  347. package/src/sany/generator-expressions.ts +1100 -0
  348. package/src/sany/generator-proofs.ts +662 -0
  349. package/src/sany/generator.ts +191 -2764
  350. package/src/sany/levels.ts +6 -34
  351. package/src/sany/lexer.ts +58 -77
  352. package/src/sany/linter.ts +1 -9
  353. package/src/sany/modules.ts +1 -5
  354. package/src/sany/nodes.ts +5 -43
  355. package/src/sany/parse-error.ts +39 -117
  356. package/src/sany/report.ts +32 -69
  357. package/src/sany/selectors.ts +49 -76
  358. package/src/sany/source.ts +1 -17
  359. package/src/sany/xml.ts +35 -117
  360. package/src/search.ts +541 -163
  361. package/src/simulate.ts +709 -0
  362. package/src/spec-description.ts +192 -100
  363. package/src/standard-definitions.ts +0 -4
  364. package/src/standard-modules.ts +264 -95
  365. package/src/state-graph.ts +52 -31
  366. package/src/subexpressions.ts +69 -52
  367. package/src/substitution-levels.ts +7 -7
  368. package/src/successors.ts +266 -99
  369. package/src/symmetry.ts +33 -25
  370. package/src/tableau.ts +27 -24
  371. package/src/tlc/fingerprint.ts +183 -67
  372. package/src/tlc/jar-data.ts +112 -6
  373. package/src/tlc/messages.ts +125 -54
  374. package/src/tlc/order.ts +39 -69
  375. package/src/tlc/random.ts +37 -49
  376. package/src/tlc/replay.ts +553 -228
  377. package/src/tlc/summary.ts +36 -47
  378. package/src/tlc/tlc-operators.ts +78 -44
  379. package/src/tlc/tlcext-operators.ts +139 -122
  380. package/src/tlc/trace-spec.ts +249 -0
  381. package/src/tlc/value-stream.ts +139 -0
  382. package/src/tlc/version.ts +1 -4
  383. package/src/transfer.ts +22 -25
  384. package/src/typescript/actions.ts +479 -0
  385. package/src/typescript/collections.ts +614 -0
  386. package/src/typescript/compile.ts +63 -0
  387. package/src/typescript/context.ts +94 -0
  388. package/src/typescript/emit.ts +121 -0
  389. package/src/typescript/expressions.ts +496 -0
  390. package/src/typescript/formula.ts +154 -0
  391. package/src/typescript/functions.ts +284 -0
  392. package/src/typescript/model.ts +162 -0
  393. package/src/typescript/names.ts +114 -0
  394. package/src/typescript/program.ts +48 -0
  395. package/src/typescript/properties.ts +139 -0
  396. package/src/typescript/scope.ts +112 -0
  397. package/src/typescript/steps.ts +167 -0
  398. package/src/typescript/types.ts +171 -0
  399. package/src/values.ts +832 -484
  400. package/src/worker.ts +7 -8
@@ -1,7 +1,6 @@
1
1
  import { TlaEvaluationError } from "./errors";
2
2
  import { hasRepeatedEffects, type Environment } from "./evaluate";
3
3
  import {
4
- createTautologyError,
5
4
  evaluateLive,
6
5
  evaluateOnLasso,
7
6
  toLiveExpression,
@@ -28,16 +27,11 @@ export interface LiveSuccessor {
28
27
  export interface Lasso {
29
28
  prefix: number[];
30
29
  cycle: number[];
31
- // Whether the solution that the lasso violates constrains the cycle, as a liveness property does.
32
- // TLC warns that a stuttering counterexample to one may come from a missing fairness constraint.
33
30
  isCycleConstrained: boolean;
34
31
  }
35
32
 
36
33
  export interface LivenessChecker {
37
- // How many solutions of the negated properties TLC checks, which it calls branches.
38
34
  branches: number;
39
- // With a tracing environment, the checks record their call stack as TLC's replay of a failed
40
- // check does.
41
35
  addInitialState: (index: number, state: Value[], tracing?: Environment) => void;
42
36
  addState: (
43
37
  index: number,
@@ -54,32 +48,23 @@ interface SearchGraph {
54
48
  getSuccessors: (index: number, state: Value[]) => LiveSuccessor[];
55
49
  }
56
50
 
57
- // Numbers in a typed array that doubles as it fills, so a graph of millions of nodes takes a few
58
- // bytes for each.
59
51
  interface Pool<Data extends Int32Array | Uint8Array> {
60
52
  data: Data;
61
53
  length: number;
62
54
  create: (length: number) => Data;
63
55
  }
64
56
 
65
- // TLC's behavior graph for one solution: a node per state, or per state and tableau node.
66
57
  interface BehaviorGraph {
67
58
  solution: Solution;
68
- // One id per distinct action check across the solutions.
69
59
  actionIds: Int32Array;
70
60
  nodeStates: number[];
71
61
  nodeTableaux: number[];
72
- // Where a node's edges start in edgeTargets, or UNWRITTEN until TLC writes the node with its
73
- // successors, and how many it has.
74
62
  edgeStarts: number[];
75
63
  edgeCounts: number[];
76
64
  edgeTargets: Pool<Int32Array>;
77
- // The results of the action checks on each edge, and of the state checks on each state, which
78
- // are the same for every node of the state.
79
65
  edgeActions: Pool<Uint8Array>;
80
66
  stateResults: Pool<Uint8Array>;
81
67
  initial: number[];
82
- // The nodes of each state in the order they are recorded, a list through nextSiblings.
83
68
  firstNodes: Pool<Int32Array>;
84
69
  lastNodes: Pool<Int32Array>;
85
70
  nextSiblings: number[];
@@ -104,15 +89,14 @@ const containsAlways = (expression: LiveExpression): boolean => {
104
89
  }
105
90
  };
106
91
 
107
- // TLC's OrderOfSolution#hasEmptyPEMAndBoxFreePromises, negated.
92
+ const isEmptyModel = (model: Solution["models"][number]) =>
93
+ model.eventuallyAlways.length === 0 &&
94
+ model.infinitelyOftenStates.length === 0 &&
95
+ model.infinitelyOftenActions.length === 0;
96
+
108
97
  const isCycleConstrained = (solution: Solution) =>
109
98
  solution.promises.some((promise) => containsAlways(promise.body)) ||
110
- solution.models.some(
111
- (model) =>
112
- model.eventuallyAlways.length > 0 ||
113
- model.infinitelyOftenStates.length > 0 ||
114
- model.infinitelyOftenActions.length > 0,
115
- );
99
+ solution.models.some((model) => !isEmptyModel(model));
116
100
 
117
101
  const isSameState = (left: Value[], right: Value[]) =>
118
102
  left.every((value, position) => isSameValue(value, right[position]));
@@ -141,8 +125,7 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
141
125
 
142
126
  const NO_NODE = -1;
143
127
 
144
- // A Map holds at most 2^24 entries, so each tableau node of a state finds its node in an
145
- // open-addressing table of (state plus one, tableau node, node) triples.
128
+ // A Map holds at most 2^24 entries, so an open-addressing table of (state plus one, tableau node, node) triples finds each node.
146
129
  interface NodeTable {
147
130
  slots: Int32Array;
148
131
  size: number;
@@ -178,7 +161,6 @@ const getStateResult = (behavior: BehaviorGraph, node: number, position: number)
178
161
  behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
179
162
  ] === 1;
180
163
 
181
- // A node owns one entry in each per-node array of its graph.
182
164
  const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
183
165
  behavior.nodeStates.push(state);
184
166
  behavior.nodeTableaux.push(tableauNode);
@@ -225,17 +207,14 @@ export const createLivenessChecker = (
225
207
  const formula =
226
208
  fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
227
209
  const solutions = getSolutions(formula);
228
- if (solutions.length === 0) {
229
- throw createTautologyError();
230
- }
231
210
  const actionIds = new Map<string, number>();
232
211
  const behaviors = solutions.map((solution): BehaviorGraph => ({
233
212
  solution,
234
213
  actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
235
214
  const key = getTermKey(predicate);
236
- const id = actionIds.get(key) ?? actionIds.size;
237
- actionIds.set(key, id);
238
- return id;
215
+ const actionId = actionIds.get(key) ?? actionIds.size;
216
+ actionIds.set(key, actionId);
217
+ return actionId;
239
218
  }),
240
219
  nodeStates: [],
241
220
  nodeTableaux: [],
@@ -252,34 +231,31 @@ export const createLivenessChecker = (
252
231
  isDone: [],
253
232
  errorNode: undefined,
254
233
  }));
255
- const capacity = { multiplier: 1 };
234
+ let capacityMultiplier = 1;
256
235
 
257
- // TLC evaluates every check on its own. Without side effects the order can't show, so the
258
- // checks of one state share their results.
259
236
  const isShared = !hasRepeatedEffects(environment);
260
- const evaluation = { environment };
261
- const shared = {
262
- states: new Map<Value[], Map<LiveExpression, boolean>>(),
263
- actions: new Map<Value[], Map<Value[], Int8Array>>(),
264
- };
237
+ let evaluationEnvironment = environment;
238
+ const sharedStates = new Map<Value[], Map<LiveExpression, boolean>>();
239
+ const sharedActions = new Map<Value[], Map<Value[], Int8Array>>();
265
240
  const getStateCache = (state: Value[]) => {
266
- const cache = shared.states.get(state) ?? new Map<LiveExpression, boolean>();
267
- shared.states.set(state, cache);
241
+ const cache = sharedStates.get(state) ?? new Map<LiveExpression, boolean>();
242
+ sharedStates.set(state, cache);
268
243
  return cache;
269
244
  };
270
- // TLCGet("level") reads the level of the state whose successors the checks run on.
271
245
  const evaluateFrom = <Result>(source: number | undefined, evaluate: () => Result) => {
272
246
  environment.runtime.setLivenessSource(source);
273
- const result = evaluate();
274
- environment.runtime.setLivenessSource(undefined);
275
- return result;
247
+ try {
248
+ return evaluate();
249
+ } finally {
250
+ environment.runtime.setLivenessSource(undefined);
251
+ }
276
252
  };
277
253
  const evaluateState = (predicate: LiveExpression, state: Value[]) =>
278
254
  evaluateLive(
279
255
  predicate,
280
256
  state,
281
257
  undefined,
282
- evaluation.environment,
258
+ evaluationEnvironment,
283
259
  isShared ? getStateCache(state) : new Map(),
284
260
  );
285
261
  const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
@@ -298,27 +274,27 @@ export const createLivenessChecker = (
298
274
  const predicates = behavior.solution.actionChecks;
299
275
  if (!isShared) {
300
276
  return Uint8Array.from(predicates, (predicate) =>
301
- evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
277
+ evaluateLive(predicate, state, successor, evaluationEnvironment, new Map()) ? 1 : 0,
302
278
  );
303
279
  }
304
280
  const stateCache = getStateCache(state);
305
- const results = shared.actions.get(state) ?? new Map<Value[], Int8Array>();
306
- shared.actions.set(state, results);
281
+ const results = sharedActions.get(state) ?? new Map<Value[], Int8Array>();
282
+ sharedActions.set(state, results);
307
283
  const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
308
284
  results.set(successor, known);
309
- return Uint8Array.from(behavior.actionIds, (id, position) => {
310
- if (known[id] === -1) {
311
- known[id] = evaluateLive(
285
+ return Uint8Array.from(behavior.actionIds, (actionId, position) => {
286
+ if (known[actionId] === -1) {
287
+ known[actionId] = evaluateLive(
312
288
  predicates[position],
313
289
  state,
314
290
  successor,
315
- evaluation.environment,
291
+ evaluationEnvironment,
316
292
  stateCache,
317
293
  )
318
294
  ? 1
319
295
  : 0;
320
296
  }
321
- return known[id];
297
+ return known[actionId];
322
298
  });
323
299
  });
324
300
  const isConsistent = (
@@ -330,8 +306,6 @@ export const createLivenessChecker = (
330
306
  evaluateFrom(source, () =>
331
307
  tableau.nodes[node].statePredicates.every((predicate) => evaluateState(predicate, state)),
332
308
  );
333
- // TLC 1.7.4 doesn't stop at a tableau node that accepts every behavior, so it finds a violation
334
- // of a property like a safety property only in its liveness checks.
335
309
  const isAccepting = (tableau: Tableau, node: number) => {
336
310
  if (environment.runtime.version === "1.7.4") return false;
337
311
  const tableauNode = tableau.nodes[node];
@@ -341,13 +315,6 @@ export const createLivenessChecker = (
341
315
  tableauNode.successors[0] === node
342
316
  );
343
317
  };
344
- const hasEmptyModel = (behavior: BehaviorGraph) =>
345
- behavior.solution.models.some(
346
- (model) =>
347
- model.eventuallyAlways.length === 0 &&
348
- model.infinitelyOftenStates.length === 0 &&
349
- model.infinitelyOftenActions.length === 0,
350
- );
351
318
 
352
319
  const getNodeId = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
353
320
  if (!behavior.solution.tableau) return state;
@@ -400,16 +367,12 @@ export const createLivenessChecker = (
400
367
  behavior.edgeCounts[node] = targets.length;
401
368
  };
402
369
 
403
- // TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
404
- // iterates in slot order. Its capacity starts at 16 times a factor that grows with every set
405
- // that outgrows it.
370
+ // TLC iterates a state's successors and the state itself in the slot order of a SetOfStates, a hash set whose capacity grows with every set that outgrows it.
406
371
  const getSuccessorSet = (index: number, state: Value[], successors: LiveSuccessor[]) => {
407
- const table = {
408
- slots: Array.from<LiveSuccessor | undefined>({
409
- length: SUCCESSOR_CAPACITY * capacity.multiplier,
410
- }),
411
- count: 0,
412
- };
372
+ let successorSlots = Array.from<LiveSuccessor | undefined>({
373
+ length: SUCCESSOR_CAPACITY * capacityMultiplier,
374
+ });
375
+ let successorCount = 0;
413
376
  const insertSuccessor = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
414
377
  for (
415
378
  let slot = (search.getFingerprint(successor) & 0x7fffffff) % slots.length;
@@ -426,20 +389,19 @@ export const createLivenessChecker = (
426
389
  }
427
390
  };
428
391
  const addSuccessor = (successor: LiveSuccessor) => {
429
- if (table.count >= table.slots.length >> 1) {
430
- const old = table.slots;
431
- table.slots = Array.from<LiveSuccessor | undefined>({ length: 2 * old.length + 1 });
432
- for (const entry of old) if (entry) insertSuccessor(table.slots, entry);
392
+ if (successorCount >= successorSlots.length >> 1) {
393
+ const old = successorSlots;
394
+ successorSlots = Array.from<LiveSuccessor | undefined>({ length: 2 * old.length + 1 });
395
+ for (const entry of old) if (entry) insertSuccessor(successorSlots, entry);
433
396
  }
434
- if (insertSuccessor(table.slots, successor)) table.count++;
397
+ if (insertSuccessor(successorSlots, successor)) successorCount++;
435
398
  };
436
399
  successors.forEach(addSuccessor);
437
400
  addSuccessor({ index, state });
438
- if (table.slots.length > SUCCESSOR_CAPACITY * capacity.multiplier) capacity.multiplier++;
439
- return table.slots.filter((entry): entry is LiveSuccessor => entry !== undefined);
401
+ if (successorSlots.length > SUCCESSOR_CAPACITY * capacityMultiplier) capacityMultiplier++;
402
+ return successorSlots.filter((entry): entry is LiveSuccessor => entry !== undefined);
440
403
  };
441
404
 
442
- // TLC's TableauLiveChecker#addNextState for a node it finds after it expanded the node's state.
443
405
  const expandLate = (
444
406
  behavior: BehaviorGraph,
445
407
  tableau: Tableau,
@@ -460,7 +422,7 @@ export const createLivenessChecker = (
460
422
  if (
461
423
  isAccepting(tableau, next) &&
462
424
  behavior.errorNode === undefined &&
463
- hasEmptyModel(behavior)
425
+ behavior.solution.models.some(isEmptyModel)
464
426
  ) {
465
427
  behavior.errorNode = node;
466
428
  return;
@@ -477,8 +439,7 @@ export const createLivenessChecker = (
477
439
  const isDone = behavior.isDone[successor.index] === true;
478
440
  for (const next of tableauNode.successors) {
479
441
  if (!isConsistent(tableau, next, index, successor.state)) continue;
480
- // A successor the search never stored follows a violation or an error, after which nothing
481
- // checks the graph. TLC records its node, which it never expands.
442
+ // Deviation from TLC: TLC records the node of a successor the search never stored, which it never expands.
482
443
  if (successor.index === -1) continue;
483
444
  const existing = getNodeId(behavior, successor.index, next);
484
445
  if (existing !== undefined && successors.includes(existing)) continue;
@@ -501,7 +462,7 @@ export const createLivenessChecker = (
501
462
  stateResults: Uint8Array,
502
463
  index: number,
503
464
  ) => {
504
- const consistency = tableau.nodes.map((_, node) =>
465
+ const consistency = tableau.nodes.map((_tableauNode, node) =>
505
466
  set.map((successor) => isConsistent(tableau, node, index, successor.state)),
506
467
  );
507
468
  behavior.isDone[index] = true;
@@ -525,12 +486,9 @@ export const createLivenessChecker = (
525
486
  });
526
487
  writeNode(behavior, node, successors, actions, stateResults);
527
488
  }
528
- if (behavior.errorNode === undefined) return undefined;
529
- return removeRepeats(
530
- getPath(behavior, behavior.errorNode)
531
- .reverse()
532
- .map((node) => behavior.nodeStates[node]),
533
- );
489
+ return behavior.errorNode === undefined
490
+ ? undefined
491
+ : getStatePath(behavior, behavior.errorNode);
534
492
  };
535
493
 
536
494
  const addPlainState = (
@@ -551,7 +509,6 @@ export const createLivenessChecker = (
551
509
  writeNode(behavior, index, successors, actions, stateResults);
552
510
  };
553
511
 
554
- // The shortest path from an initial node to the node, last node first, as TLC's getPath finds it.
555
512
  const getPath = (behavior: BehaviorGraph, target: number) => {
556
513
  if (behavior.initial.includes(target)) return [target];
557
514
  const parents = new Map<number, number>();
@@ -578,7 +535,13 @@ export const createLivenessChecker = (
578
535
  throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
579
536
  };
580
537
 
581
- // TLC's LiveWorker#checkSccs, a Tarjan search that pushes every successor of a node at once.
538
+ const getStatePath = (behavior: BehaviorGraph, target: number) =>
539
+ removeRepeats(
540
+ getPath(behavior, target)
541
+ .reverse()
542
+ .map((node) => behavior.nodeStates[node]),
543
+ );
544
+
582
545
  const findLassoInModel = (
583
546
  behavior: BehaviorGraph,
584
547
  model: Solution["models"][number],
@@ -635,91 +598,85 @@ export const createLivenessChecker = (
635
598
  return getLasso(root, members, membersByState);
636
599
  };
637
600
 
638
- // TLC's LiveWorker#printTrace: a prefix to the root, a greedy walk through the component
639
- // until it satisfies every check, and a breadth-first path back to the root.
640
601
  const getLasso = (
641
602
  root: number,
642
603
  members: Set<number>,
643
604
  membersByState: Map<number, number[]>,
644
605
  ) => {
645
- const prefix = removeRepeats(
646
- getPath(behavior, root)
647
- .reverse()
648
- .map((node) => behavior.nodeStates[node]),
649
- );
606
+ const prefix = getStatePath(behavior, root);
650
607
  const cycleStack: number[] = [];
651
608
  const seen = new Set<number>([root]);
652
609
  const stateDone = model.infinitelyOftenStates.map(() => false);
653
610
  const actionDone = model.infinitelyOftenActions.map(() => false);
654
611
  const promiseDone = solution.promises.map(() => false);
655
- const remaining = { count: stateDone.length + actionDone.length + promiseDone.length };
656
- const current = { node: root };
657
- const isMember = (node: number) => members.has(node);
612
+ let remainingCount = stateDone.length + actionDone.length + promiseDone.length;
613
+ let currentNode = root;
658
614
  const moveTo = (next: number) => {
659
- cycleStack.push(current.node);
660
- current.node = next;
615
+ cycleStack.push(currentNode);
616
+ currentNode = next;
661
617
  };
662
- while (remaining.count > 0) {
663
- const countAtStart = remaining.count;
618
+ while (remainingCount > 0) {
619
+ const countAtStart = remainingCount;
664
620
  while (true) {
665
621
  model.infinitelyOftenStates.forEach((position, slot) => {
666
- if (!stateDone[slot] && getStateResult(behavior, current.node, position)) {
622
+ if (!stateDone[slot] && getStateResult(behavior, currentNode, position)) {
667
623
  stateDone[slot] = true;
668
- remaining.count--;
624
+ remainingCount--;
669
625
  }
670
626
  });
671
627
  solution.promises.forEach((promise, position) => {
672
- if (!promiseDone[position] && isFulfilled(current.node, promise)) {
628
+ if (!promiseDone[position] && isFulfilled(currentNode, promise)) {
673
629
  promiseDone[position] = true;
674
- remaining.count--;
630
+ remainingCount--;
675
631
  }
676
632
  });
677
- if (remaining.count <= 0) break;
678
- const step = { last: -1, unvisited: -1 };
679
- const countBeforeActions = remaining.count;
680
- const taken = getNodeSuccessors(behavior, current.node).some((next, edge) => {
633
+ if (remainingCount <= 0) break;
634
+ let lastNext = -1;
635
+ let unvisitedNext = -1;
636
+ const countBeforeActions = remainingCount;
637
+ const isTaken = getNodeSuccessors(behavior, currentNode).some((next, edge) => {
681
638
  if (membersByState.has(behavior.nodeStates[next])) {
682
- if (!isMember(next) || !isAllowed(current.node, edge)) return false;
683
- step.last = next;
639
+ if (!members.has(next) || !isAllowed(currentNode, edge)) return false;
640
+ lastNext = next;
684
641
  model.infinitelyOftenActions.forEach((position, slot) => {
685
- if (!actionDone[slot] && getAction(current.node, edge, position)) {
642
+ if (!actionDone[slot] && getAction(currentNode, edge, position)) {
686
643
  actionDone[slot] = true;
687
- remaining.count--;
644
+ remainingCount--;
688
645
  }
689
646
  });
690
647
  }
691
- if (remaining.count < countBeforeActions) {
648
+ if (remainingCount < countBeforeActions) {
692
649
  moveTo(next);
693
650
  seen.clear();
694
651
  return true;
695
652
  }
696
- if (isMember(next) && !seen.has(next)) step.unvisited = next;
653
+ if (members.has(next) && !seen.has(next)) unvisitedNext = next;
697
654
  return false;
698
655
  });
699
- if (taken) break;
700
- if (remaining.count < countAtStart) {
701
- moveTo(step.last);
656
+ if (isTaken) break;
657
+ if (remainingCount < countAtStart) {
658
+ moveTo(lastNext);
702
659
  seen.clear();
703
660
  break;
704
661
  }
705
- while (step.unvisited === -1) {
662
+ while (unvisitedNext === -1) {
706
663
  const previous = cycleStack.pop();
707
664
  if (previous === undefined) {
708
665
  throw new TlaEvaluationError(
709
666
  "TLC failed to build the counterexample of a liveness property",
710
667
  );
711
668
  }
712
- current.node = previous;
713
- step.unvisited =
669
+ currentNode = previous;
670
+ unvisitedNext =
714
671
  getNodeSuccessors(behavior, previous).find(
715
- (next) => isMember(next) && !seen.has(next),
672
+ (next) => members.has(next) && !seen.has(next),
716
673
  ) ?? -1;
717
674
  }
718
- moveTo(step.unvisited);
719
- seen.add(step.unvisited);
675
+ moveTo(unvisitedNext);
676
+ seen.add(unvisitedNext);
720
677
  }
721
678
  }
722
- const postfix = getClosingPath(root, current.node, membersByState, isAllowed);
679
+ const postfix = getClosingPath(root, currentNode, membersByState);
723
680
  for (let position = cycleStack.length - 1; position >= 0; position--) {
724
681
  const state = behavior.nodeStates[cycleStack[position]];
725
682
  if (postfix[postfix.length - 1] !== state) postfix.push(state);
@@ -733,13 +690,7 @@ export const createLivenessChecker = (
733
690
  };
734
691
  };
735
692
 
736
- // TLC's LiveWorker#bfsPostFix, the states from the walk's end back to the root, last first.
737
- const getClosingPath = (
738
- root: number,
739
- end: number,
740
- membersByState: Map<number, number[]>,
741
- isAllowedEdge: (node: number, edge: number) => boolean,
742
- ) => {
693
+ const getClosingPath = (root: number, end: number, membersByState: Map<number, number[]>) => {
743
694
  if (end === root) return [];
744
695
  const start = behavior.nodeStates[end];
745
696
  const parents = new Map<number, number>();
@@ -748,7 +699,7 @@ export const createLivenessChecker = (
748
699
  for (let state = start, parent = -1, position = 0; ; position++) {
749
700
  for (const node of membersByState.get(state) ?? []) {
750
701
  for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
751
- if (next === node || !isAllowedEdge(node, edge)) continue;
702
+ if (next === node || !isAllowed(node, edge)) continue;
752
703
  if (next === root) {
753
704
  const path: number[] = [];
754
705
  for (let item = state, itemParent = parent; item !== start;) {
@@ -779,7 +730,7 @@ export const createLivenessChecker = (
779
730
 
780
731
  for (let position = 0; position < queue.length; position++) {
781
732
  const stack = [queue[position], UNVISITED, 0];
782
- const counter = { link: 0 };
733
+ let nextLink = 0;
783
734
  while (stack.length >= 3) {
784
735
  const lowLink = stack.pop() ?? 0;
785
736
  const location = stack.pop();
@@ -796,10 +747,10 @@ export const createLivenessChecker = (
796
747
  stack.push(Math.min(lowLink, links[node]));
797
748
  continue;
798
749
  }
799
- links[node] = counter.link;
750
+ links[node] = nextLink;
800
751
  stack.push(lowLink, node, SCC_MARKER);
801
752
  components.push(node);
802
- const nextLowLink = { value: counter.link++ };
753
+ let nextLowLink = nextLink++;
803
754
  getNodeSuccessors(behavior, node).forEach((next, edge) => {
804
755
  if (!isWritten(behavior, next)) return;
805
756
  if (!isAllowed(node, edge)) {
@@ -807,9 +758,9 @@ export const createLivenessChecker = (
807
758
  return;
808
759
  }
809
760
  if (links[next] === UNVISITED) stack.push(next, UNVISITED);
810
- else nextLowLink.value = Math.min(nextLowLink.value, links[next]);
761
+ else nextLowLink = Math.min(nextLowLink, links[next]);
811
762
  });
812
- stack.push(nextLowLink.value);
763
+ stack.push(nextLowLink);
813
764
  }
814
765
  }
815
766
  return undefined;
@@ -818,9 +769,9 @@ export const createLivenessChecker = (
818
769
  return {
819
770
  branches: behaviors.length,
820
771
  addInitialState: (index, state, tracing) => {
821
- evaluation.environment = tracing ?? environment;
822
- shared.states.clear();
823
- shared.actions.clear();
772
+ evaluationEnvironment = tracing ?? environment;
773
+ sharedStates.clear();
774
+ sharedActions.clear();
824
775
  try {
825
776
  for (const behavior of behaviors) {
826
777
  const tableau = behavior.solution.tableau;
@@ -836,13 +787,13 @@ export const createLivenessChecker = (
836
787
  }
837
788
  }
838
789
  } finally {
839
- evaluation.environment = environment;
790
+ evaluationEnvironment = environment;
840
791
  }
841
792
  },
842
793
  addState: (index, state, successors, tracing) => {
843
- evaluation.environment = tracing ?? environment;
844
- shared.states.clear();
845
- shared.actions.clear();
794
+ evaluationEnvironment = tracing ?? environment;
795
+ sharedStates.clear();
796
+ sharedActions.clear();
846
797
  try {
847
798
  const set = getSuccessorSet(index, state, successors);
848
799
  for (const behavior of behaviors) {
@@ -867,7 +818,7 @@ export const createLivenessChecker = (
867
818
  }
868
819
  return undefined;
869
820
  } finally {
870
- evaluation.environment = environment;
821
+ evaluationEnvironment = environment;
871
822
  }
872
823
  },
873
824
  findViolation: () => {
@@ -879,12 +830,11 @@ export const createLivenessChecker = (
879
830
  }
880
831
  return undefined;
881
832
  },
882
- // TLC names every property that the counterexample violates, once each.
883
833
  getViolatedProperties: (path, cycleStart) => [
884
834
  ...new Set(
885
835
  properties
886
836
  .filter(
887
- (_, position) =>
837
+ (_property, position) =>
888
838
  !evaluateOnLasso(negations[position].body, path, cycleStart, 0, environment),
889
839
  )
890
840
  .map((property) => property.name),