tla-ts 0.0.4 → 0.0.5-dev.5b2dea1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (378) hide show
  1. package/README.md +38 -127
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +46 -12
  8. package/dist/index.d.ts +46 -12
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +76 -92
  23. package/dist/transfer.js +76 -92
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +21 -12
  27. package/src/ast.ts +2 -2
  28. package/src/bags.ts +22 -23
  29. package/src/builtins.ts +16 -8
  30. package/src/check.ts +131 -1153
  31. package/src/{cli-options.ts → cli/options.ts} +54 -9
  32. package/src/cli/run.ts +63 -0
  33. package/src/cli/shared.ts +106 -0
  34. package/src/cli/tlapm.ts +374 -0
  35. package/src/{run-cli.ts → cli/tlc.ts} +115 -721
  36. package/src/cli/xml-exporter.ts +221 -0
  37. package/src/cli.ts +1 -1
  38. package/src/codegen.ts +43 -22
  39. package/src/config.ts +5 -5
  40. package/src/dependencies.ts +4 -6
  41. package/src/environment.ts +55 -60
  42. package/src/errors.ts +97 -35
  43. package/src/evaluate.ts +361 -181
  44. package/src/exit-codes.ts +1 -1
  45. package/src/fingerprints.ts +3 -3
  46. package/src/index.ts +10 -0
  47. package/src/instances.ts +56 -46
  48. package/src/java-overrides.ts +79 -41
  49. package/src/json.ts +31 -36
  50. package/src/levels.ts +10 -13
  51. package/src/{live-check.ts → liveness-checker.ts} +207 -141
  52. package/src/liveness.ts +38 -34
  53. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  54. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  55. package/src/obligations/equality.ts +260 -0
  56. package/src/obligations/expression.ts +618 -0
  57. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  58. package/src/obligations/generate.ts +457 -0
  59. package/src/{obligations.ts → obligations/index.ts} +46 -32
  60. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  61. package/src/obligations/module.ts +445 -0
  62. package/src/obligations/normalize.ts +554 -0
  63. package/src/obligations/operators.ts +176 -0
  64. package/src/obligations/pragma.ts +195 -0
  65. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  66. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  67. package/src/obligations/regroup.ts +100 -0
  68. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  69. package/src/{obligation-source.ts → obligations/source.ts} +172 -216
  70. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  71. package/src/obligations/substitution.ts +261 -0
  72. package/src/obligations/temporal.ts +321 -0
  73. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  74. package/src/parallel-worker.ts +39 -51
  75. package/src/parallel.ts +39 -66
  76. package/src/parser.ts +67 -74
  77. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  78. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  79. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  80. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  81. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  82. package/src/prover/decide-pool.ts +95 -0
  83. package/src/prover/deciders.ts +33 -0
  84. package/src/prover/first-order.ts +175 -0
  85. package/src/prover/isabelle/LICENSE +36 -0
  86. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  87. package/src/prover/isabelle/decide.ts +44 -0
  88. package/src/prover/isabelle/encode.ts +445 -0
  89. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  90. package/src/prover/isabelle/isar/method.ts +367 -0
  91. package/src/prover/isabelle/isar/proof.ts +28 -0
  92. package/src/prover/isabelle/isar/statement.ts +57 -0
  93. package/src/prover/isabelle/isar/theory.ts +192 -0
  94. package/src/prover/isabelle/isar/type-check.ts +278 -0
  95. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  96. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  97. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  98. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  99. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  100. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  101. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  102. package/src/prover/isabelle/provers/classical.ts +389 -0
  103. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  104. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  105. package/src/prover/isabelle/pure/consts.ts +32 -0
  106. package/src/prover/isabelle/pure/conv.ts +79 -0
  107. package/src/prover/isabelle/pure/drule.ts +264 -0
  108. package/src/prover/isabelle/pure/envir.ts +331 -0
  109. package/src/prover/isabelle/pure/goal.ts +53 -0
  110. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  111. package/src/prover/isabelle/pure/list.ts +12 -0
  112. package/src/prover/isabelle/pure/logic.ts +330 -0
  113. package/src/prover/isabelle/pure/name.ts +98 -0
  114. package/src/prover/isabelle/pure/net.ts +215 -0
  115. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  116. package/src/prover/isabelle/pure/pattern.ts +631 -0
  117. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  118. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  119. package/src/prover/isabelle/pure/search.ts +68 -0
  120. package/src/prover/isabelle/pure/seq.ts +133 -0
  121. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  122. package/src/prover/isabelle/pure/table.ts +201 -0
  123. package/src/prover/isabelle/pure/tactic.ts +168 -0
  124. package/src/prover/isabelle/pure/tactical.ts +264 -0
  125. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  126. package/src/prover/isabelle/pure/term.ts +688 -0
  127. package/src/prover/isabelle/pure/thm.ts +783 -0
  128. package/src/prover/isabelle/pure/type.ts +121 -0
  129. package/src/prover/isabelle/pure/unify.ts +753 -0
  130. package/src/prover/isabelle/pure/variable.ts +25 -0
  131. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  132. package/src/prover/isabelle/tla/context.ts +74 -0
  133. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  134. package/src/prover/isabelle/tla/logic.ts +215 -0
  135. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  136. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  137. package/src/prover/ocaml.ts +22 -0
  138. package/src/prover/prep/action.ts +508 -0
  139. package/src/prover/prep/enabled-axioms.ts +189 -0
  140. package/src/prover/prep/fingerprint.ts +388 -0
  141. package/src/prover/prep/level-comparison.ts +529 -0
  142. package/src/prover/prep/md5.ts +60 -0
  143. package/src/prover/prep/methods.ts +221 -0
  144. package/src/prover/prep/normalize.ts +309 -0
  145. package/src/prover/prove-worker.ts +22 -0
  146. package/src/prover/prove.ts +492 -0
  147. package/src/prover/ptl/decide.ts +68 -0
  148. package/src/prover/ptl/encode.ts +244 -0
  149. package/src/prover/ptl/sat.ts +151 -0
  150. package/src/prover/ptl/tableau.ts +276 -0
  151. package/src/prover/smt/axioms.ts +209 -0
  152. package/src/prover/smt/context.ts +108 -0
  153. package/src/prover/smt/data.ts +636 -0
  154. package/src/prover/smt/encode.ts +275 -0
  155. package/src/prover/smt/extensionality.ts +65 -0
  156. package/src/prover/smt/flatten.ts +112 -0
  157. package/src/prover/smt/format.ts +154 -0
  158. package/src/prover/smt/instances.ts +181 -0
  159. package/src/prover/smt/rewrite.ts +766 -0
  160. package/src/prover/smt/solver/act-cache.ts +265 -0
  161. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  162. package/src/prover/smt/solver/array.ts +22 -0
  163. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  164. package/src/prover/smt/solver/ast-lt.ts +157 -0
  165. package/src/prover/smt/solver/ast-util.ts +91 -0
  166. package/src/prover/smt/solver/ast.ts +1315 -0
  167. package/src/prover/smt/solver/auf-solver.ts +572 -0
  168. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  169. package/src/prover/smt/solver/cg-table.ts +175 -0
  170. package/src/prover/smt/solver/clause.ts +276 -0
  171. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  172. package/src/prover/smt/solver/context.ts +1292 -0
  173. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  174. package/src/prover/smt/solver/der.ts +224 -0
  175. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  176. package/src/prover/smt/solver/e-matching.ts +659 -0
  177. package/src/prover/smt/solver/enode.ts +259 -0
  178. package/src/prover/smt/solver/expr-ref.ts +21 -0
  179. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  180. package/src/prover/smt/solver/fingerprints.ts +92 -0
  181. package/src/prover/smt/solver/flat-literals.ts +51 -0
  182. package/src/prover/smt/solver/goal.ts +138 -0
  183. package/src/prover/smt/solver/hash.ts +173 -0
  184. package/src/prover/smt/solver/hashtable.ts +166 -0
  185. package/src/prover/smt/solver/internalizer.ts +1381 -0
  186. package/src/prover/smt/solver/lbool.ts +5 -0
  187. package/src/prover/smt/solver/literal.ts +24 -0
  188. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  189. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  190. package/src/prover/smt/solver/lp/containers.ts +296 -0
  191. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  192. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  193. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  194. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  195. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  196. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  197. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  198. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  199. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  200. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  201. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  202. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  203. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  204. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  205. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  206. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  207. package/src/prover/smt/solver/lp/nex.ts +120 -0
  208. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  209. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  210. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  211. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  212. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  213. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  214. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  215. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  216. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  217. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  218. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  219. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  220. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  221. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  222. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  223. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  224. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  225. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  226. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  227. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  228. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  229. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  230. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  231. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  232. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  233. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  234. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  235. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  236. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  237. package/src/prover/smt/solver/model-checker.ts +347 -0
  238. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  239. package/src/prover/smt/solver/model-finder.ts +155 -0
  240. package/src/prover/smt/solver/model-generator.ts +97 -0
  241. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  242. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  243. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  244. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  245. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  246. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  247. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  248. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  249. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  250. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  251. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  252. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +645 -0
  253. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  254. package/src/prover/smt/solver/nnf.ts +469 -0
  255. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  256. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  257. package/src/prover/smt/solver/propagate-values.ts +83 -0
  258. package/src/prover/smt/solver/proto-model.ts +551 -0
  259. package/src/prover/smt/solver/pull-quant.ts +139 -0
  260. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  261. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  262. package/src/prover/smt/solver/qe-lite.ts +381 -0
  263. package/src/prover/smt/solver/qi-queue.ts +362 -0
  264. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  265. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  266. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  267. package/src/prover/smt/solver/random-gen.ts +10 -0
  268. package/src/prover/smt/solver/rational.ts +165 -0
  269. package/src/prover/smt/solver/ref-vector.ts +62 -0
  270. package/src/prover/smt/solver/relevancy.ts +247 -0
  271. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  272. package/src/prover/smt/solver/rewriter.ts +843 -0
  273. package/src/prover/smt/solver/rlimit.ts +84 -0
  274. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  275. package/src/prover/smt/solver/solver.ts +71 -0
  276. package/src/prover/smt/solver/sort.ts +35 -0
  277. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  278. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  279. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  280. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  281. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  282. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  283. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  284. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  285. package/src/prover/smt/solver/theory-lra.ts +56 -0
  286. package/src/prover/smt/solver/var-subst.ts +258 -0
  287. package/src/prover/smt/solver/z3-license.txt +10 -0
  288. package/src/prover/smt/table.ts +170 -0
  289. package/src/prover/tlapm/cache.ts +236 -0
  290. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  291. package/src/prover/tlapm/tlapm.ts +96 -0
  292. package/src/prover/tlaps-module.ts +510 -0
  293. package/src/prover/verdict.ts +13 -0
  294. package/src/prover/zenon/LICENSE +32 -0
  295. package/src/prover/zenon/check/check.ts +105 -0
  296. package/src/prover/zenon/check/definitions.ts +144 -0
  297. package/src/prover/zenon/check/equality.ts +182 -0
  298. package/src/prover/zenon/check/functions.ts +62 -0
  299. package/src/prover/zenon/check/keys.ts +125 -0
  300. package/src/prover/zenon/check/propositional.ts +104 -0
  301. package/src/prover/zenon/check/records.ts +188 -0
  302. package/src/prover/zenon/check/relations.ts +121 -0
  303. package/src/prover/zenon/check/rewrites.ts +224 -0
  304. package/src/prover/zenon/check/sets.ts +302 -0
  305. package/src/prover/zenon/check/terms.ts +127 -0
  306. package/src/prover/zenon/check/tla.ts +126 -0
  307. package/src/prover/zenon/decide.ts +107 -0
  308. package/src/prover/zenon/encode.ts +378 -0
  309. package/src/prover/zenon/eqrel.ts +300 -0
  310. package/src/prover/zenon/equality-rules.ts +435 -0
  311. package/src/prover/zenon/expr.ts +551 -0
  312. package/src/prover/zenon/index-table.ts +350 -0
  313. package/src/prover/zenon/isar-case.ts +513 -0
  314. package/src/prover/zenon/isar.ts +1249 -0
  315. package/src/prover/zenon/limits.ts +15 -0
  316. package/src/prover/zenon/llproof.ts +173 -0
  317. package/src/prover/zenon/mltoll.ts +1566 -0
  318. package/src/prover/zenon/node.ts +297 -0
  319. package/src/prover/zenon/ocaml.ts +169 -0
  320. package/src/prover/zenon/parse.ts +247 -0
  321. package/src/prover/zenon/phrase.ts +191 -0
  322. package/src/prover/zenon/proof.ts +198 -0
  323. package/src/prover/zenon/propositional-rules.ts +387 -0
  324. package/src/prover/zenon/rules.ts +94 -0
  325. package/src/prover/zenon/search.ts +288 -0
  326. package/src/prover/zenon/tla/functions.ts +151 -0
  327. package/src/prover/zenon/tla/llproof.ts +480 -0
  328. package/src/prover/zenon/tla/records.ts +225 -0
  329. package/src/prover/zenon/tla/rewrites.ts +447 -0
  330. package/src/prover/zenon/tla/sets.ts +304 -0
  331. package/src/prover/zenon/tla/terms.ts +162 -0
  332. package/src/prover/zenon/tla/tla.ts +506 -0
  333. package/src/randomization.ts +19 -24
  334. package/src/resolve.ts +15 -22
  335. package/src/runtime.ts +8 -8
  336. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  337. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  338. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  339. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  340. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  341. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  342. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  343. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  344. package/src/{sany-report.ts → sany/report.ts} +16 -17
  345. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  346. package/src/{sany-source.ts → sany/source.ts} +6 -7
  347. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  348. package/src/search.ts +969 -0
  349. package/src/spec-description.ts +26 -20
  350. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  351. package/src/standard-modules.ts +21 -22
  352. package/src/state-graph.ts +9 -8
  353. package/src/substitution-levels.ts +2 -2
  354. package/src/successors.ts +39 -23
  355. package/src/symmetry.ts +1 -1
  356. package/src/tableau.ts +6 -7
  357. package/src/tlc/fingerprint.ts +214 -0
  358. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  359. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  360. package/src/{tlc-random.ts → tlc/random.ts} +3 -190
  361. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  362. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  363. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  364. package/src/{tlc-version.ts → tlc/version.ts} +8 -7
  365. package/src/transfer.ts +32 -32
  366. package/src/values.ts +166 -111
  367. package/src/worker.ts +62 -0
  368. package/dist/parallel.cjs +0 -12
  369. package/dist/parallel.js +0 -12
  370. package/dist/run-cli.cjs +0 -55
  371. package/dist/run-cli.js +0 -55
  372. package/src/canonical.ts +0 -40
  373. package/src/obligation-expression.ts +0 -1060
  374. package/src/obligation-module.ts +0 -1042
  375. package/src/standard-ranges.ts +0 -116
  376. package/src/value-sources.ts +0 -29
  377. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  378. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
@@ -49,7 +49,7 @@ export interface LivenessChecker {
49
49
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
50
50
  }
51
51
 
52
- export interface LiveGraph {
52
+ interface SearchGraph {
53
53
  getFingerprint: (successor: LiveSuccessor) => number;
54
54
  getSuccessors: (index: number, state: Value[]) => LiveSuccessor[];
55
55
  }
@@ -63,7 +63,7 @@ interface Pool<Data extends Int32Array | Uint8Array> {
63
63
  }
64
64
 
65
65
  // TLC's behavior graph for one solution: a node per state, or per state and tableau node.
66
- interface Check {
66
+ interface BehaviorGraph {
67
67
  solution: Solution;
68
68
  // One id per distinct action check across the solutions.
69
69
  actionIds: Int32Array;
@@ -79,10 +79,11 @@ interface Check {
79
79
  edgeActions: Pool<Uint8Array>;
80
80
  stateResults: Pool<Uint8Array>;
81
81
  initial: number[];
82
- // The nodes of each state in the order the check records them, a list through nextSiblings.
82
+ // The nodes of each state in the order they are recorded, a list through nextSiblings.
83
83
  firstNodes: Pool<Int32Array>;
84
84
  lastNodes: Pool<Int32Array>;
85
85
  nextSiblings: number[];
86
+ nodeIds: NodeTable;
86
87
  isDone: boolean[];
87
88
  errorNode: number | undefined;
88
89
  }
@@ -140,39 +141,59 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
140
141
 
141
142
  const NO_NODE = -1;
142
143
 
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.
146
+ interface NodeTable {
147
+ slots: Int32Array;
148
+ size: number;
149
+ shift: number;
150
+ }
151
+
152
+ const getNodeSlot = (table: NodeTable, state: number, tableauNode: number) => {
153
+ const mask = table.slots.length / 3 - 1;
154
+ const hash = Math.imul(Math.imul(state, 0x9e3779b1) ^ tableauNode, 0x85ebca6b) >>> table.shift;
155
+ for (let index = hash; ; index = (index + 1) & mask) {
156
+ const slot = index * 3;
157
+ const stored = table.slots[slot];
158
+ if (stored === 0 || (stored === state + 1 && table.slots[slot + 1] === tableauNode)) {
159
+ return slot;
160
+ }
161
+ }
162
+ };
163
+
143
164
  const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
144
165
 
145
166
  const UNWRITTEN = -1;
146
167
 
147
- const isWritten = (check: Check, node: number) =>
148
- (check.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
168
+ const isWritten = (behavior: BehaviorGraph, node: number) =>
169
+ (behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
149
170
 
150
- const getSuccessors = (check: Check, node: number) => {
151
- const start = check.edgeStarts[node];
152
- return check.edgeTargets.data.subarray(start, start + check.edgeCounts[node]);
171
+ const getNodeSuccessors = (behavior: BehaviorGraph, node: number) => {
172
+ const start = behavior.edgeStarts[node];
173
+ return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
153
174
  };
154
175
 
155
- const getStateResult = (check: Check, node: number, position: number) =>
156
- check.stateResults.data[check.nodeStates[node] * check.solution.stateChecks.length + position] ===
157
- 1;
158
-
159
- // A node owns one entry in each of its check's per-node arrays.
160
- const pushNode = (check: Check, state: number, tableauNode: number) => {
161
- check.nodeStates.push(state);
162
- check.nodeTableaux.push(tableauNode);
163
- check.edgeStarts.push(UNWRITTEN);
164
- check.edgeCounts.push(0);
165
- check.nextSiblings.push(NO_NODE);
166
- return check.nodeStates.length - 1;
176
+ const getStateResult = (behavior: BehaviorGraph, node: number, position: number) =>
177
+ behavior.stateResults.data[
178
+ behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
179
+ ] === 1;
180
+
181
+ // A node owns one entry in each per-node array of its graph.
182
+ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
183
+ behavior.nodeStates.push(state);
184
+ behavior.nodeTableaux.push(tableauNode);
185
+ behavior.edgeStarts.push(UNWRITTEN);
186
+ behavior.edgeCounts.push(0);
187
+ behavior.nextSiblings.push(NO_NODE);
188
+ return behavior.nodeStates.length - 1;
167
189
  };
168
190
 
169
- // The nodes of the state, in the order the check recorded them.
170
- const getStateNodes = (check: Check, state: number) => {
191
+ const getStateNodes = (behavior: BehaviorGraph, state: number) => {
171
192
  const nodes: number[] = [];
172
193
  for (
173
- let node = check.firstNodes.data[state] ?? NO_NODE;
194
+ let node = behavior.firstNodes.data[state] ?? NO_NODE;
174
195
  node !== NO_NODE;
175
- node = check.nextSiblings[node]
196
+ node = behavior.nextSiblings[node]
176
197
  ) {
177
198
  nodes.push(node);
178
199
  }
@@ -191,7 +212,7 @@ export const createLivenessChecker = (
191
212
  properties: TemporalProperty[],
192
213
  temporals: ScopedExpression[],
193
214
  environment: Environment,
194
- graph: LiveGraph,
215
+ search: SearchGraph,
195
216
  ): LivenessChecker | undefined => {
196
217
  if (properties.length === 0) return undefined;
197
218
  const fairness = temporals.map((item) =>
@@ -208,7 +229,7 @@ export const createLivenessChecker = (
208
229
  throw createTautologyError();
209
230
  }
210
231
  const actionIds = new Map<string, number>();
211
- const checks = solutions.map((solution): Check => ({
232
+ const behaviors = solutions.map((solution): BehaviorGraph => ({
212
233
  solution,
213
234
  actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
214
235
  const key = getTermKey(predicate);
@@ -227,6 +248,7 @@ export const createLivenessChecker = (
227
248
  firstNodes: createPool(createNodes),
228
249
  lastNodes: createPool(createNodes),
229
250
  nextSiblings: [],
251
+ nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
230
252
  isDone: [],
231
253
  errorNode: undefined,
232
254
  }));
@@ -260,15 +282,20 @@ export const createLivenessChecker = (
260
282
  evaluation.environment,
261
283
  isShared ? getStateCache(state) : new Map(),
262
284
  );
263
- const checkState = (check: Check, source: number, state: Value[]) =>
285
+ const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
264
286
  evaluateFrom(source, () =>
265
- Uint8Array.from(check.solution.stateChecks, (predicate) =>
287
+ Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
266
288
  evaluateState(predicate, state) ? 1 : 0,
267
289
  ),
268
290
  );
269
- const checkAction = (check: Check, source: number, state: Value[], successor: Value[]) =>
291
+ const checkAction = (
292
+ behavior: BehaviorGraph,
293
+ source: number,
294
+ state: Value[],
295
+ successor: Value[],
296
+ ) =>
270
297
  evaluateFrom(source, () => {
271
- const predicates = check.solution.actionChecks;
298
+ const predicates = behavior.solution.actionChecks;
272
299
  if (!isShared) {
273
300
  return Uint8Array.from(predicates, (predicate) =>
274
301
  evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
@@ -279,7 +306,7 @@ export const createLivenessChecker = (
279
306
  shared.actions.set(state, results);
280
307
  const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
281
308
  results.set(successor, known);
282
- return Uint8Array.from(check.actionIds, (id, position) => {
309
+ return Uint8Array.from(behavior.actionIds, (id, position) => {
283
310
  if (known[id] === -1) {
284
311
  known[id] = evaluateLive(
285
312
  predicates[position],
@@ -314,42 +341,63 @@ export const createLivenessChecker = (
314
341
  tableauNode.successors[0] === node
315
342
  );
316
343
  };
317
- const hasEmptyModel = (check: Check) =>
318
- check.solution.models.some(
344
+ const hasEmptyModel = (behavior: BehaviorGraph) =>
345
+ behavior.solution.models.some(
319
346
  (model) =>
320
347
  model.eventuallyAlways.length === 0 &&
321
348
  model.infinitelyOftenStates.length === 0 &&
322
349
  model.infinitelyOftenActions.length === 0,
323
350
  );
324
351
 
325
- const getNodeId = (check: Check, state: number, tableauNode: number) =>
326
- check.solution.tableau
327
- ? getStateNodes(check, state).find((node) => check.nodeTableaux[node] === tableauNode)
328
- : state;
329
- const recordNode = (check: Check, state: number, tableauNode: number) => {
330
- const node = pushNode(check, state, tableauNode);
331
- const last = check.lastNodes.data[state] ?? NO_NODE;
332
- if (last === NO_NODE) writeToPool(check.firstNodes, state, [node]);
333
- else check.nextSiblings[last] = node;
334
- writeToPool(check.lastNodes, state, [node]);
352
+ const getNodeId = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
353
+ if (!behavior.solution.tableau) return state;
354
+ const slots = behavior.nodeIds.slots;
355
+ const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
356
+ return slots[slot] === 0 ? undefined : slots[slot + 2];
357
+ };
358
+ const recordNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
359
+ const node = pushNode(behavior, state, tableauNode);
360
+ const table = behavior.nodeIds;
361
+ if (++table.size * 2 > table.slots.length / 3) {
362
+ const old = table.slots;
363
+ table.slots = new Int32Array(old.length * 2);
364
+ table.shift--;
365
+ for (let slot = 0; slot < old.length; slot += 3) {
366
+ if (old[slot] !== 0) {
367
+ table.slots.set(
368
+ old.subarray(slot, slot + 3),
369
+ getNodeSlot(table, old[slot] - 1, old[slot + 1]),
370
+ );
371
+ }
372
+ }
373
+ }
374
+ table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
375
+ const last = behavior.lastNodes.data[state] ?? NO_NODE;
376
+ if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
377
+ else behavior.nextSiblings[last] = node;
378
+ writeToPool(behavior.lastNodes, state, [node]);
335
379
  return node;
336
380
  };
337
381
  const writeNode = (
338
- check: Check,
382
+ behavior: BehaviorGraph,
339
383
  node: number,
340
384
  targets: number[],
341
385
  actions: Uint8Array[],
342
386
  stateResults: Uint8Array,
343
387
  ) => {
344
- const start = check.edgeTargets.length;
345
- const actionCount = check.solution.actionChecks.length;
346
- writeToPool(check.edgeTargets, start, targets);
388
+ const start = behavior.edgeTargets.length;
389
+ const actionCount = behavior.solution.actionChecks.length;
390
+ writeToPool(behavior.edgeTargets, start, targets);
347
391
  actions.forEach((results, position) =>
348
- writeToPool(check.edgeActions, (start + position) * actionCount, results),
392
+ writeToPool(behavior.edgeActions, (start + position) * actionCount, results),
349
393
  );
350
- writeToPool(check.stateResults, check.nodeStates[node] * stateResults.length, stateResults);
351
- check.edgeStarts[node] = start;
352
- check.edgeCounts[node] = targets.length;
394
+ writeToPool(
395
+ behavior.stateResults,
396
+ behavior.nodeStates[node] * stateResults.length,
397
+ stateResults,
398
+ );
399
+ behavior.edgeStarts[node] = start;
400
+ behavior.edgeCounts[node] = targets.length;
353
401
  };
354
402
 
355
403
  // TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
@@ -362,9 +410,9 @@ export const createLivenessChecker = (
362
410
  }),
363
411
  count: 0,
364
412
  };
365
- const insert = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
413
+ const insertSuccessor = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
366
414
  for (
367
- let slot = (graph.getFingerprint(successor) & 0x7fffffff) % slots.length;
415
+ let slot = (search.getFingerprint(successor) & 0x7fffffff) % slots.length;
368
416
  ;
369
417
  slot = (slot + 1) % slots.length
370
418
  ) {
@@ -377,72 +425,76 @@ export const createLivenessChecker = (
377
425
  return false;
378
426
  }
379
427
  };
380
- const put = (successor: LiveSuccessor) => {
428
+ const addSuccessor = (successor: LiveSuccessor) => {
381
429
  if (table.count >= table.slots.length >> 1) {
382
430
  const old = table.slots;
383
431
  table.slots = Array.from<LiveSuccessor | undefined>({ length: 2 * old.length + 1 });
384
- for (const entry of old) if (entry) insert(table.slots, entry);
432
+ for (const entry of old) if (entry) insertSuccessor(table.slots, entry);
385
433
  }
386
- if (insert(table.slots, successor)) table.count++;
434
+ if (insertSuccessor(table.slots, successor)) table.count++;
387
435
  };
388
- successors.forEach(put);
389
- put({ index, state });
436
+ successors.forEach(addSuccessor);
437
+ addSuccessor({ index, state });
390
438
  if (table.slots.length > SUCCESSOR_CAPACITY * capacity.multiplier) capacity.multiplier++;
391
439
  return table.slots.filter((entry): entry is LiveSuccessor => entry !== undefined);
392
440
  };
393
441
 
394
442
  // TLC's TableauLiveChecker#addNextState for a node it finds after it expanded the node's state.
395
443
  const expandLate = (
396
- check: Check,
444
+ behavior: BehaviorGraph,
397
445
  tableau: Tableau,
398
446
  state: Value[],
399
447
  index: number,
400
448
  node: number,
401
449
  ) => {
402
- const stateResults = checkState(check, index, state);
403
- const tableauNode = tableau.nodes[check.nodeTableaux[node]];
450
+ const stateResults = checkState(behavior, index, state);
451
+ const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
404
452
  const actions: Uint8Array[] = [];
405
453
  const successors: number[] = [];
406
454
  const selfActions =
407
455
  tableauNode.successors.length > 0
408
- ? checkAction(check, index, state, state)
456
+ ? checkAction(behavior, index, state, state)
409
457
  : new Uint8Array(0);
410
458
  for (const next of tableauNode.successors) {
411
459
  if (!isConsistent(tableau, next, index, state)) continue;
412
- if (isAccepting(tableau, next) && check.errorNode === undefined && hasEmptyModel(check)) {
413
- check.errorNode = node;
460
+ if (
461
+ isAccepting(tableau, next) &&
462
+ behavior.errorNode === undefined &&
463
+ hasEmptyModel(behavior)
464
+ ) {
465
+ behavior.errorNode = node;
414
466
  return;
415
467
  }
416
- const existing = getNodeId(check, index, next);
468
+ const existing = getNodeId(behavior, index, next);
417
469
  if (existing !== undefined && successors.includes(existing)) continue;
418
- const target = existing ?? recordNode(check, index, next);
470
+ const target = existing ?? recordNode(behavior, index, next);
419
471
  successors.push(target);
420
472
  actions.push(selfActions);
421
- if (existing === undefined) expandLate(check, tableau, state, index, target);
473
+ if (existing === undefined) expandLate(behavior, tableau, state, index, target);
422
474
  }
423
- for (const successor of graph.getSuccessors(index, state)) {
424
- const successorActions = checkAction(check, index, state, successor.state);
425
- const isDone = check.isDone[successor.index] === true;
475
+ for (const successor of search.getSuccessors(index, state)) {
476
+ const successorActions = checkAction(behavior, index, state, successor.state);
477
+ const isDone = behavior.isDone[successor.index] === true;
426
478
  for (const next of tableauNode.successors) {
427
479
  if (!isConsistent(tableau, next, index, successor.state)) continue;
428
480
  // A successor the search never stored follows a violation or an error, after which nothing
429
481
  // checks the graph. TLC records its node, which it never expands.
430
482
  if (successor.index === -1) continue;
431
- const existing = getNodeId(check, successor.index, next);
483
+ const existing = getNodeId(behavior, successor.index, next);
432
484
  if (existing !== undefined && successors.includes(existing)) continue;
433
- const target = existing ?? recordNode(check, successor.index, next);
485
+ const target = existing ?? recordNode(behavior, successor.index, next);
434
486
  successors.push(target);
435
487
  actions.push(successorActions);
436
488
  if (existing === undefined && isDone) {
437
- expandLate(check, tableau, successor.state, successor.index, target);
489
+ expandLate(behavior, tableau, successor.state, successor.index, target);
438
490
  }
439
491
  }
440
492
  }
441
- if (successors.length > 0) writeNode(check, node, successors, actions, stateResults);
493
+ if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
442
494
  };
443
495
 
444
496
  const addTableauState = (
445
- check: Check,
497
+ behavior: BehaviorGraph,
446
498
  tableau: Tableau,
447
499
  set: LiveSuccessor[],
448
500
  actionResults: Uint8Array[],
@@ -452,74 +504,73 @@ export const createLivenessChecker = (
452
504
  const consistency = tableau.nodes.map((_, node) =>
453
505
  set.map((successor) => isConsistent(tableau, node, index, successor.state)),
454
506
  );
455
- check.isDone[index] = true;
507
+ behavior.isDone[index] = true;
456
508
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
457
- for (const node of getStateNodes(check, index)) {
509
+ for (const node of getStateNodes(behavior, index)) {
458
510
  const successors: number[] = [];
459
511
  const actions: Uint8Array[] = [];
460
512
  set.forEach((successor, position) => {
461
- const isDone = check.isDone[successor.index] === true;
462
- for (const next of tableau.nodes[check.nodeTableaux[node]].successors) {
513
+ const isDone = behavior.isDone[successor.index] === true;
514
+ for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
463
515
  if (!consistency[next][position]) continue;
464
- const existing = getNodeId(check, successor.index, next);
516
+ const existing = getNodeId(behavior, successor.index, next);
465
517
  if (existing !== undefined && successors.includes(existing)) continue;
466
- const target = existing ?? recordNode(check, successor.index, next);
518
+ const target = existing ?? recordNode(behavior, successor.index, next);
467
519
  successors.push(target);
468
520
  actions.push(actionResults[position]);
469
521
  if (existing === undefined && isDone) {
470
- expandLate(check, tableau, successor.state, successor.index, target);
522
+ expandLate(behavior, tableau, successor.state, successor.index, target);
471
523
  }
472
524
  }
473
525
  });
474
- writeNode(check, node, successors, actions, stateResults);
526
+ writeNode(behavior, node, successors, actions, stateResults);
475
527
  }
476
- if (check.errorNode === undefined) return undefined;
528
+ if (behavior.errorNode === undefined) return undefined;
477
529
  return removeRepeats(
478
- getPath(check, check.errorNode)
530
+ getPath(behavior, behavior.errorNode)
479
531
  .reverse()
480
- .map((node) => check.nodeStates[node]),
532
+ .map((node) => behavior.nodeStates[node]),
481
533
  );
482
534
  };
483
535
 
484
536
  const addPlainState = (
485
- check: Check,
537
+ behavior: BehaviorGraph,
486
538
  set: LiveSuccessor[],
487
539
  actionResults: Uint8Array[],
488
540
  stateResults: Uint8Array,
489
541
  index: number,
490
542
  ) => {
491
- while (check.nodeStates.length <= index) pushNode(check, check.nodeStates.length, -1);
543
+ while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
492
544
  const successors: number[] = [];
493
545
  const actions: Uint8Array[] = [];
494
546
  set.forEach((successor, position) => {
495
- if (isWritten(check, successor.index) && successors.includes(successor.index)) return;
547
+ if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
496
548
  successors.push(successor.index);
497
549
  actions.push(actionResults[position]);
498
550
  });
499
- writeNode(check, index, successors, actions, stateResults);
500
- return undefined;
551
+ writeNode(behavior, index, successors, actions, stateResults);
501
552
  };
502
553
 
503
554
  // The shortest path from an initial node to the node, last node first, as TLC's getPath finds it.
504
- const getPath = (check: Check, target: number) => {
505
- if (check.initial.includes(target)) return [target];
555
+ const getPath = (behavior: BehaviorGraph, target: number) => {
556
+ if (behavior.initial.includes(target)) return [target];
506
557
  const parents = new Map<number, number>();
507
558
  const queue: number[] = [];
508
- for (const node of check.initial) {
509
- if (!isWritten(check, node)) continue;
559
+ for (const node of behavior.initial) {
560
+ if (!isWritten(behavior, node)) continue;
510
561
  queue.push(node);
511
562
  parents.set(node, -1);
512
563
  }
513
564
  for (let position = 0; position < queue.length; position++) {
514
565
  const current = queue[position];
515
- for (const next of getSuccessors(check, current)) {
516
- if (next === current && check.solution.tableau) continue;
566
+ for (const next of getNodeSuccessors(behavior, current)) {
567
+ if (next === current && behavior.solution.tableau) continue;
517
568
  if (next === target) {
518
569
  const path = [target];
519
570
  for (let node = current; node !== -1; node = parents.get(node) ?? -1) path.push(node);
520
571
  return path;
521
572
  }
522
- if (!isWritten(check, next) || parents.has(next)) continue;
573
+ if (!isWritten(behavior, next) || parents.has(next)) continue;
523
574
  parents.set(next, current);
524
575
  queue.push(next);
525
576
  }
@@ -528,24 +579,27 @@ export const createLivenessChecker = (
528
579
  };
529
580
 
530
581
  // TLC's LiveWorker#checkSccs, a Tarjan search that pushes every successor of a node at once.
531
- const findInModel = (check: Check, model: Solution["models"][number]): Lasso | undefined => {
532
- const solution = check.solution;
582
+ const findLassoInModel = (
583
+ behavior: BehaviorGraph,
584
+ model: Solution["models"][number],
585
+ ): Lasso | undefined => {
586
+ const solution = behavior.solution;
533
587
  const actionCount = solution.actionChecks.length;
534
588
  const getAction = (node: number, edge: number, position: number) =>
535
- check.edgeActions.data[(check.edgeStarts[node] + edge) * actionCount + position] === 1;
589
+ behavior.edgeActions.data[(behavior.edgeStarts[node] + edge) * actionCount + position] === 1;
536
590
  const isAllowed = (node: number, edge: number) =>
537
591
  model.eventuallyAlways.every((position) => getAction(node, edge, position));
538
- const links = new Float64Array(check.nodeStates.length).fill(UNVISITED);
539
- const queue = check.initial.filter((node) => isWritten(check, node));
592
+ const links = new Float64Array(behavior.nodeStates.length).fill(UNVISITED);
593
+ const queue = behavior.initial.filter((node) => isWritten(behavior, node));
540
594
  const components: number[] = [];
541
595
 
542
596
  const isStuttering = (node: number) => {
543
- const edge = getSuccessors(check, node).indexOf(node);
597
+ const edge = getNodeSuccessors(behavior, node).indexOf(node);
544
598
  return edge !== -1 && isAllowed(node, edge);
545
599
  };
546
600
  const isFulfilled = (node: number, promise: Solution["promises"][number]) =>
547
601
  solution.tableau !== undefined &&
548
- isFulfilling(solution.tableau.nodes[check.nodeTableaux[node]].particle, promise);
602
+ isFulfilling(solution.tableau.nodes[behavior.nodeTableaux[node]].particle, promise);
549
603
 
550
604
  const checkComponent = (root: number) => {
551
605
  const top = components.pop() ?? root;
@@ -557,18 +611,18 @@ export const createLivenessChecker = (
557
611
  const membersByState = new Map<number, number[]>();
558
612
  for (let member = top; ; member = components.pop() ?? root) {
559
613
  members.add(member);
560
- const siblings = membersByState.get(check.nodeStates[member]);
614
+ const siblings = membersByState.get(behavior.nodeStates[member]);
561
615
  if (siblings) siblings.push(member);
562
- else membersByState.set(check.nodeStates[member], [member]);
616
+ else membersByState.set(behavior.nodeStates[member], [member]);
563
617
  links[member] = MAXIMUM_LINK;
564
618
  if (member === root) break;
565
619
  }
566
620
  const isStateSatisfied = model.infinitelyOftenStates.every((position) =>
567
- [...members].some((node) => getStateResult(check, node, position)),
621
+ [...members].some((node) => getStateResult(behavior, node, position)),
568
622
  );
569
623
  const isActionSatisfied = model.infinitelyOftenActions.every((position) =>
570
624
  [...members].some((node) =>
571
- getSuccessors(check, node).some(
625
+ getNodeSuccessors(behavior, node).some(
572
626
  (next, edge) =>
573
627
  members.has(next) && isAllowed(node, edge) && getAction(node, edge, position),
574
628
  ),
@@ -589,9 +643,9 @@ export const createLivenessChecker = (
589
643
  membersByState: Map<number, number[]>,
590
644
  ) => {
591
645
  const prefix = removeRepeats(
592
- getPath(check, root)
646
+ getPath(behavior, root)
593
647
  .reverse()
594
- .map((node) => check.nodeStates[node]),
648
+ .map((node) => behavior.nodeStates[node]),
595
649
  );
596
650
  const cycleStack: number[] = [];
597
651
  const seen = new Set<number>([root]);
@@ -601,7 +655,7 @@ export const createLivenessChecker = (
601
655
  const remaining = { count: stateDone.length + actionDone.length + promiseDone.length };
602
656
  const current = { node: root };
603
657
  const isMember = (node: number) => members.has(node);
604
- const take = (next: number) => {
658
+ const moveTo = (next: number) => {
605
659
  cycleStack.push(current.node);
606
660
  current.node = next;
607
661
  };
@@ -609,7 +663,7 @@ export const createLivenessChecker = (
609
663
  const countAtStart = remaining.count;
610
664
  while (true) {
611
665
  model.infinitelyOftenStates.forEach((position, slot) => {
612
- if (!stateDone[slot] && getStateResult(check, current.node, position)) {
666
+ if (!stateDone[slot] && getStateResult(behavior, current.node, position)) {
613
667
  stateDone[slot] = true;
614
668
  remaining.count--;
615
669
  }
@@ -623,8 +677,8 @@ export const createLivenessChecker = (
623
677
  if (remaining.count <= 0) break;
624
678
  const step = { last: -1, unvisited: -1 };
625
679
  const countBeforeActions = remaining.count;
626
- const taken = getSuccessors(check, current.node).some((next, edge) => {
627
- if (membersByState.has(check.nodeStates[next])) {
680
+ const taken = getNodeSuccessors(behavior, current.node).some((next, edge) => {
681
+ if (membersByState.has(behavior.nodeStates[next])) {
628
682
  if (!isMember(next) || !isAllowed(current.node, edge)) return false;
629
683
  step.last = next;
630
684
  model.infinitelyOftenActions.forEach((position, slot) => {
@@ -635,7 +689,7 @@ export const createLivenessChecker = (
635
689
  });
636
690
  }
637
691
  if (remaining.count < countBeforeActions) {
638
- take(next);
692
+ moveTo(next);
639
693
  seen.clear();
640
694
  return true;
641
695
  }
@@ -644,7 +698,7 @@ export const createLivenessChecker = (
644
698
  });
645
699
  if (taken) break;
646
700
  if (remaining.count < countAtStart) {
647
- take(step.last);
701
+ moveTo(step.last);
648
702
  seen.clear();
649
703
  break;
650
704
  }
@@ -657,16 +711,17 @@ export const createLivenessChecker = (
657
711
  }
658
712
  current.node = previous;
659
713
  step.unvisited =
660
- getSuccessors(check, previous).find((next) => isMember(next) && !seen.has(next)) ??
661
- -1;
714
+ getNodeSuccessors(behavior, previous).find(
715
+ (next) => isMember(next) && !seen.has(next),
716
+ ) ?? -1;
662
717
  }
663
- take(step.unvisited);
718
+ moveTo(step.unvisited);
664
719
  seen.add(step.unvisited);
665
720
  }
666
721
  }
667
722
  const postfix = getClosingPath(root, current.node, membersByState, isAllowed);
668
723
  for (let position = cycleStack.length - 1; position >= 0; position--) {
669
- const state = check.nodeStates[cycleStack[position]];
724
+ const state = behavior.nodeStates[cycleStack[position]];
670
725
  if (postfix[postfix.length - 1] !== state) postfix.push(state);
671
726
  }
672
727
  const cycleState = prefix[prefix.length - 1];
@@ -686,13 +741,13 @@ export const createLivenessChecker = (
686
741
  isAllowedEdge: (node: number, edge: number) => boolean,
687
742
  ) => {
688
743
  if (end === root) return [];
689
- const start = check.nodeStates[end];
744
+ const start = behavior.nodeStates[end];
690
745
  const parents = new Map<number, number>();
691
746
  const seen = new Set<number>([start]);
692
747
  const queue: [number, number][] = [];
693
748
  for (let state = start, parent = -1, position = 0; ; position++) {
694
749
  for (const node of membersByState.get(state) ?? []) {
695
- for (const [edge, next] of getSuccessors(check, node).entries()) {
750
+ for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
696
751
  if (next === node || !isAllowedEdge(node, edge)) continue;
697
752
  if (next === root) {
698
753
  const path: number[] = [];
@@ -704,7 +759,7 @@ export const createLivenessChecker = (
704
759
  path.push(start);
705
760
  return path;
706
761
  }
707
- const nextState = check.nodeStates[next];
762
+ const nextState = behavior.nodeStates[next];
708
763
  if (!membersByState.has(nextState) || seen.has(nextState)) continue;
709
764
  seen.add(nextState);
710
765
  queue.push([nextState, state]);
@@ -745,8 +800,8 @@ export const createLivenessChecker = (
745
800
  stack.push(lowLink, node, SCC_MARKER);
746
801
  components.push(node);
747
802
  const nextLowLink = { value: counter.link++ };
748
- getSuccessors(check, node).forEach((next, edge) => {
749
- if (!isWritten(check, next)) return;
803
+ getNodeSuccessors(behavior, node).forEach((next, edge) => {
804
+ if (!isWritten(behavior, next)) return;
750
805
  if (!isAllowed(node, edge)) {
751
806
  if (links[next] === UNVISITED) queue.push(next);
752
807
  return;
@@ -761,21 +816,23 @@ export const createLivenessChecker = (
761
816
  };
762
817
 
763
818
  return {
764
- branches: checks.length,
819
+ branches: behaviors.length,
765
820
  addInitialState: (index, state, tracing) => {
766
821
  evaluation.environment = tracing ?? environment;
767
822
  shared.states.clear();
768
823
  shared.actions.clear();
769
824
  try {
770
- for (const check of checks) {
771
- const tableau = check.solution.tableau;
825
+ for (const behavior of behaviors) {
826
+ const tableau = behavior.solution.tableau;
772
827
  if (!tableau) {
773
- check.initial.push(index);
828
+ behavior.initial.push(index);
774
829
  continue;
775
830
  }
776
831
  for (let node = 0; node < tableau.initialCount; node++) {
777
832
  if (!isConsistent(tableau, node, undefined, state)) continue;
778
- check.initial.push(getNodeId(check, index, node) ?? recordNode(check, index, node));
833
+ behavior.initial.push(
834
+ getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
835
+ );
779
836
  }
780
837
  }
781
838
  } finally {
@@ -788,15 +845,24 @@ export const createLivenessChecker = (
788
845
  shared.actions.clear();
789
846
  try {
790
847
  const set = getSuccessorSet(index, state, successors);
791
- for (const check of checks) {
848
+ for (const behavior of behaviors) {
792
849
  const actionResults = set.map((successor) =>
793
- checkAction(check, index, state, successor.state),
850
+ checkAction(behavior, index, state, successor.state),
851
+ );
852
+ const stateResults = checkState(behavior, index, state);
853
+ const tableau = behavior.solution.tableau;
854
+ if (!tableau) {
855
+ addPlainState(behavior, set, actionResults, stateResults, index);
856
+ continue;
857
+ }
858
+ const accepted = addTableauState(
859
+ behavior,
860
+ tableau,
861
+ set,
862
+ actionResults,
863
+ stateResults,
864
+ index,
794
865
  );
795
- const stateResults = checkState(check, index, state);
796
- const tableau = check.solution.tableau;
797
- const accepted = tableau
798
- ? addTableauState(check, tableau, set, actionResults, stateResults, index)
799
- : addPlainState(check, set, actionResults, stateResults, index);
800
866
  if (accepted) return accepted;
801
867
  }
802
868
  return undefined;
@@ -805,9 +871,9 @@ export const createLivenessChecker = (
805
871
  }
806
872
  },
807
873
  findViolation: () => {
808
- for (const check of checks) {
809
- for (const model of check.solution.models) {
810
- const lasso = findInModel(check, model);
874
+ for (const behavior of behaviors) {
875
+ for (const model of behavior.solution.models) {
876
+ const lasso = findLassoInModel(behavior, model);
811
877
  if (lasso) return lasso;
812
878
  }
813
879
  }