tla-ts 0.0.9 → 0.0.10-dev.06b481ee0

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 (631) hide show
  1. package/README.md +30 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +48 -44
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +122 -12
  8. package/dist/index.d.ts +122 -12
  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 +2746 -410
  15. package/dist/prove.js +2745 -409
  16. package/dist/run.cjs +144 -31
  17. package/dist/run.js +144 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +134 -104
  21. package/dist/transfer.js +134 -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 +56 -60
  26. package/src/bags.ts +128 -110
  27. package/src/builtins.ts +31 -77
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check-failure.ts +118 -0
  30. package/src/check-trace.ts +320 -0
  31. package/src/check.ts +1156 -888
  32. package/src/cli/options.ts +12 -32
  33. package/src/cli/run.ts +0 -2
  34. package/src/cli/runtime-invariants.ts +100 -0
  35. package/src/cli/shared.ts +19 -12
  36. package/src/cli/tlapm.ts +433 -82
  37. package/src/cli/tlc-arguments.ts +652 -0
  38. package/src/cli/tlc-output.ts +701 -0
  39. package/src/cli/tlc-usage.ts +360 -0
  40. package/src/cli/tlc.ts +330 -659
  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 +217 -82
  45. package/src/config.ts +140 -109
  46. package/src/coverage.ts +1019 -0
  47. package/src/dependencies.ts +101 -66
  48. package/src/dfid.ts +683 -0
  49. package/src/environment-config.ts +315 -0
  50. package/src/environment.ts +263 -370
  51. package/src/errors.ts +107 -57
  52. package/src/evaluate.ts +898 -369
  53. package/src/exit-codes.ts +63 -13
  54. package/src/fingerprints.ts +75 -11
  55. package/src/index.ts +3 -0
  56. package/src/instances.ts +137 -22
  57. package/src/java-hash.ts +21 -0
  58. package/src/java-overrides.ts +6 -21
  59. package/src/json-reader.ts +455 -0
  60. package/src/json.ts +252 -139
  61. package/src/levels.ts +231 -154
  62. package/src/lexer.ts +83 -101
  63. package/src/liveness-checker.ts +743 -322
  64. package/src/liveness.ts +230 -133
  65. package/src/obligations/action.ts +17 -44
  66. package/src/obligations/anonymize.ts +120 -95
  67. package/src/obligations/enabled-axioms.ts +218 -0
  68. package/src/obligations/equality.ts +1 -3
  69. package/src/obligations/expression.ts +37 -26
  70. package/src/obligations/format.ts +0 -10
  71. package/src/obligations/generate.ts +66 -64
  72. package/src/obligations/index.ts +39 -20
  73. package/src/obligations/levels.ts +27 -18
  74. package/src/obligations/module.ts +28 -55
  75. package/src/obligations/normalize.ts +31 -41
  76. package/src/obligations/operators.ts +0 -3
  77. package/src/obligations/pragma.ts +52 -24
  78. package/src/obligations/printer.ts +94 -63
  79. package/src/obligations/proof.ts +3 -6
  80. package/src/obligations/regroup.ts +0 -5
  81. package/src/obligations/simplify.ts +57 -63
  82. package/src/obligations/source.ts +121 -95
  83. package/src/obligations/subexpression.ts +49 -28
  84. package/src/obligations/substitution.ts +1 -5
  85. package/src/obligations/temporal.ts +12 -20
  86. package/src/obligations/tuples.ts +2 -10
  87. package/src/parallel-worker.ts +36 -60
  88. package/src/parallel.ts +64 -73
  89. package/src/parser.ts +1184 -531
  90. package/src/pcal/ast.ts +53 -86
  91. package/src/pcal/parse.ts +144 -219
  92. package/src/pcal/tokenize.ts +91 -131
  93. package/src/pcal/translate.ts +83 -130
  94. package/src/pcal/validate.ts +48 -68
  95. package/src/pretty-print.ts +7 -8
  96. package/src/prover/decide-pool.ts +8 -13
  97. package/src/prover/deciders.ts +12 -13
  98. package/src/prover/first-order.ts +0 -11
  99. package/src/prover/isabelle/decide.ts +3 -31
  100. package/src/prover/isabelle/encode.ts +82 -64
  101. package/src/prover/isabelle/isar/attrib.ts +250 -0
  102. package/src/prover/isabelle/isar/context.ts +335 -0
  103. package/src/prover/isabelle/isar/induct.ts +382 -0
  104. package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
  105. package/src/prover/isabelle/isar/method.ts +510 -226
  106. package/src/prover/isabelle/isar/proof.ts +570 -23
  107. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  108. package/src/prover/isabelle/isar/theory.ts +488 -88
  109. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  110. package/src/prover/isabelle/isar/type-check.ts +99 -38
  111. package/src/prover/isabelle/provers/blast/blast.ts +16 -105
  112. package/src/prover/isabelle/provers/blast/branch.ts +0 -33
  113. package/src/prover/isabelle/provers/blast/prove.ts +0 -36
  114. package/src/prover/isabelle/provers/blast/rules.ts +5 -45
  115. package/src/prover/isabelle/provers/blast/state.ts +1 -29
  116. package/src/prover/isabelle/provers/blast/term.ts +8 -37
  117. package/src/prover/isabelle/provers/clasimp.ts +1 -15
  118. package/src/prover/isabelle/provers/classical.ts +58 -61
  119. package/src/prover/isabelle/provers/hypsubst.ts +29 -54
  120. package/src/prover/isabelle/pure/bicompose.ts +24 -39
  121. package/src/prover/isabelle/pure/consts.ts +0 -8
  122. package/src/prover/isabelle/pure/conv.ts +2 -18
  123. package/src/prover/isabelle/pure/drule.ts +95 -45
  124. package/src/prover/isabelle/pure/envir.ts +2 -53
  125. package/src/prover/isabelle/pure/goal.ts +1 -9
  126. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  127. package/src/prover/isabelle/pure/list.ts +0 -3
  128. package/src/prover/isabelle/pure/logic.ts +1 -16
  129. package/src/prover/isabelle/pure/name.ts +1 -10
  130. package/src/prover/isabelle/pure/net.ts +2 -60
  131. package/src/prover/isabelle/pure/object-logic.ts +15 -16
  132. package/src/prover/isabelle/pure/pattern.ts +1 -20
  133. package/src/prover/isabelle/pure/raw-simplifier.ts +16 -63
  134. package/src/prover/isabelle/pure/rewriter.ts +34 -77
  135. package/src/prover/isabelle/pure/search.ts +2 -11
  136. package/src/prover/isabelle/pure/seq.ts +0 -11
  137. package/src/prover/isabelle/pure/simplifier.ts +27 -16
  138. package/src/prover/isabelle/pure/table.ts +2 -33
  139. package/src/prover/isabelle/pure/tactic.ts +11 -23
  140. package/src/prover/isabelle/pure/tactical.ts +47 -48
  141. package/src/prover/isabelle/pure/term-ord.ts +1 -7
  142. package/src/prover/isabelle/pure/term.ts +4 -47
  143. package/src/prover/isabelle/pure/thm.ts +26 -48
  144. package/src/prover/isabelle/pure/type.ts +1 -16
  145. package/src/prover/isabelle/pure/unify.ts +19 -31
  146. package/src/prover/isabelle/pure/variable.ts +2 -8
  147. package/src/prover/isabelle/tla/classical-setup.ts +17 -25
  148. package/src/prover/isabelle/tla/context.ts +65 -26
  149. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  150. package/src/prover/isabelle/tla/logic.ts +53 -32
  151. package/src/prover/isabelle/tla/simpdata.ts +45 -44
  152. package/src/prover/isabelle/tools/intuitionistic.ts +28 -21
  153. package/src/prover/ocaml.ts +4 -7
  154. package/src/prover/prep/action.ts +33 -66
  155. package/src/prover/prep/enabled-axioms.ts +22 -20
  156. package/src/prover/prep/fingerprint.ts +2 -21
  157. package/src/prover/prep/level-comparison.ts +8 -12
  158. package/src/prover/prep/md5.ts +26 -31
  159. package/src/prover/prep/methods.ts +189 -86
  160. package/src/prover/prep/normalize.ts +42 -37
  161. package/src/prover/prove-worker.ts +0 -2
  162. package/src/prover/prove.ts +398 -133
  163. package/src/prover/ptl/decide.ts +96 -56
  164. package/src/prover/ptl/encode.ts +15 -38
  165. package/src/prover/ptl/sat.ts +24 -32
  166. package/src/prover/ptl/tableau.ts +40 -28
  167. package/src/prover/smt/arithmetic.ts +310 -0
  168. package/src/prover/smt/axioms.ts +12 -15
  169. package/src/prover/smt/context.ts +60 -32
  170. package/src/prover/smt/data.ts +517 -401
  171. package/src/prover/smt/encode.ts +155 -85
  172. package/src/prover/smt/extensionality.ts +5 -13
  173. package/src/prover/smt/flatten.ts +7 -28
  174. package/src/prover/smt/format.ts +33 -14
  175. package/src/prover/smt/instances.ts +7 -11
  176. package/src/prover/smt/layout.ts +91 -0
  177. package/src/prover/smt/rewrite.ts +1021 -658
  178. package/src/prover/smt/simplify.ts +441 -0
  179. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  180. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  181. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  182. package/src/prover/smt/solver/act-cache.ts +0 -16
  183. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  184. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  185. package/src/prover/smt/solver/aig.ts +889 -0
  186. package/src/prover/smt/solver/arith-rewriter.ts +626 -56
  187. package/src/prover/smt/solver/arith-terms.ts +121 -0
  188. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  189. package/src/prover/smt/solver/array-rewriter.ts +319 -0
  190. package/src/prover/smt/solver/array.ts +1 -3
  191. package/src/prover/smt/solver/asserted-formulas.ts +241 -99
  192. package/src/prover/smt/solver/ast-lt.ts +165 -21
  193. package/src/prover/smt/solver/ast-util.ts +160 -7
  194. package/src/prover/smt/solver/ast.ts +1480 -184
  195. package/src/prover/smt/solver/auf-solver.ts +30 -56
  196. package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
  197. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  198. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  199. package/src/prover/smt/solver/bound-manager.ts +196 -0
  200. package/src/prover/smt/solver/bound-simplifier.ts +598 -0
  201. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  202. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  203. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  204. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  205. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  206. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  207. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  208. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  209. package/src/prover/smt/solver/card2bv.ts +127 -0
  210. package/src/prover/smt/solver/case-split-queue.ts +0 -10
  211. package/src/prover/smt/solver/cg-table.ts +39 -42
  212. package/src/prover/smt/solver/check-logic.ts +330 -0
  213. package/src/prover/smt/solver/clause.ts +0 -27
  214. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
  215. package/src/prover/smt/solver/conflict-resolution.ts +78 -11
  216. package/src/prover/smt/solver/context.ts +600 -187
  217. package/src/prover/smt/solver/ctx-simplify.ts +34 -52
  218. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  219. package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
  220. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  221. package/src/prover/smt/solver/demodulator.ts +786 -0
  222. package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
  223. package/src/prover/smt/solver/der.ts +39 -30
  224. package/src/prover/smt/solver/diff-neq.ts +205 -0
  225. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  226. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  227. package/src/prover/smt/solver/dt2bv-tactic.ts +296 -0
  228. package/src/prover/smt/solver/dyn-ack.ts +0 -11
  229. package/src/prover/smt/solver/e-matching.ts +9 -41
  230. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  231. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  232. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  233. package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
  234. package/src/prover/smt/solver/enode.ts +100 -23
  235. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  236. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  237. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  238. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  239. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  240. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  241. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  242. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  243. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  244. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  245. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  246. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  247. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  248. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  249. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  250. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  251. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  252. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  253. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  254. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  255. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  256. package/src/prover/smt/solver/expr-ref.ts +0 -5
  257. package/src/prover/smt/solver/expr-safe-replace.ts +26 -7
  258. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  259. package/src/prover/smt/solver/factor.ts +163 -0
  260. package/src/prover/smt/solver/fd-solver.ts +734 -0
  261. package/src/prover/smt/solver/fingerprints.ts +15 -26
  262. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  263. package/src/prover/smt/solver/flat-literals.ts +0 -9
  264. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  265. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  266. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  267. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  268. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  269. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  270. package/src/prover/smt/solver/goal.ts +179 -28
  271. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  272. package/src/prover/smt/solver/guard-set.ts +219 -0
  273. package/src/prover/smt/solver/hash.ts +0 -9
  274. package/src/prover/smt/solver/hashtable.ts +30 -23
  275. package/src/prover/smt/solver/inf-eps.ts +63 -0
  276. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  277. package/src/prover/smt/solver/internalizer.ts +113 -133
  278. package/src/prover/smt/solver/lackr.ts +381 -0
  279. package/src/prover/smt/solver/lbool.ts +0 -2
  280. package/src/prover/smt/solver/lia2card.ts +268 -0
  281. package/src/prover/smt/solver/lia2pb.ts +154 -0
  282. package/src/prover/smt/solver/literal.ts +0 -4
  283. package/src/prover/smt/solver/logic-tactics.ts +355 -0
  284. package/src/prover/smt/solver/lp/bound-propagator.ts +7 -26
  285. package/src/prover/smt/solver/lp/constraints.ts +1 -8
  286. package/src/prover/smt/solver/lp/containers.ts +18 -31
  287. package/src/prover/smt/solver/lp/core-solver.ts +35 -37
  288. package/src/prover/smt/solver/lp/cross-nested.ts +4 -21
  289. package/src/prover/smt/solver/lp/dep-intervals.ts +6 -24
  290. package/src/prover/smt/solver/lp/dependency.ts +0 -5
  291. package/src/prover/smt/solver/lp/dioph-eq.ts +8 -103
  292. package/src/prover/smt/solver/lp/explanation.ts +0 -6
  293. package/src/prover/smt/solver/lp/gomory.ts +8 -22
  294. package/src/prover/smt/solver/lp/hnf-cutter.ts +16 -23
  295. package/src/prover/smt/solver/lp/hnf.ts +10 -28
  296. package/src/prover/smt/solver/lp/int-cube.ts +17 -39
  297. package/src/prover/smt/solver/lp/int-solver.ts +3 -35
  298. package/src/prover/smt/solver/lp/lar-solver.ts +70 -83
  299. package/src/prover/smt/solver/lp/lar-term.ts +0 -5
  300. package/src/prover/smt/solver/lp/lp-settings.ts +6 -16
  301. package/src/prover/smt/solver/lp/maximize-term.ts +76 -52
  302. package/src/prover/smt/solver/lp/nex-creator.ts +7 -30
  303. package/src/prover/smt/solver/lp/nex.ts +2 -7
  304. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -5
  305. package/src/prover/smt/solver/lp/nla-basics.ts +48 -30
  306. package/src/prover/smt/solver/lp/nla-core.ts +92 -136
  307. package/src/prover/smt/solver/lp/nla-divisions.ts +31 -43
  308. package/src/prover/smt/solver/lp/nla-emonics.ts +3 -21
  309. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -4
  310. package/src/prover/smt/solver/lp/nla-grobner.ts +177 -149
  311. package/src/prover/smt/solver/lp/nla-horner.ts +2 -12
  312. package/src/prover/smt/solver/lp/nla-intervals.ts +1 -12
  313. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +15 -42
  314. package/src/prover/smt/solver/lp/nla-monotone.ts +1 -6
  315. package/src/prover/smt/solver/lp/nla-order.ts +0 -13
  316. package/src/prover/smt/solver/lp/nla-patcher.ts +3 -7
  317. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  318. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -10
  319. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -6
  320. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  321. package/src/prover/smt/solver/lp/nla-types.ts +0 -12
  322. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -26
  323. package/src/prover/smt/solver/lp/nra-solver.ts +164 -147
  324. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -4
  325. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -5
  326. package/src/prover/smt/solver/lp/pdd-simplifier.ts +61 -34
  327. package/src/prover/smt/solver/lp/pdd-solver.ts +74 -72
  328. package/src/prover/smt/solver/lp/pdd.ts +730 -358
  329. package/src/prover/smt/solver/lp/random-updater.ts +0 -9
  330. package/src/prover/smt/solver/lp/static-matrix.ts +8 -19
  331. package/src/prover/smt/solver/lp/union-find.ts +5 -5
  332. package/src/prover/smt/solver/macro-finder.ts +530 -0
  333. package/src/prover/smt/solver/mam-compiler.ts +129 -139
  334. package/src/prover/smt/solver/mam-interpreter.ts +0 -21
  335. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  336. package/src/prover/smt/solver/max-cliques.ts +105 -0
  337. package/src/prover/smt/solver/maxcore.ts +310 -0
  338. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -21
  339. package/src/prover/smt/solver/maxlex.ts +115 -0
  340. package/src/prover/smt/solver/maxsmt-base.ts +106 -0
  341. package/src/prover/smt/solver/maxsmt.ts +92 -0
  342. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  343. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  344. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  345. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  346. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  347. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  348. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  349. package/src/prover/smt/solver/model-checker.ts +20 -63
  350. package/src/prover/smt/solver/model-evaluator.ts +192 -40
  351. package/src/prover/smt/solver/model-finder.ts +14 -32
  352. package/src/prover/smt/solver/model-generator.ts +104 -46
  353. package/src/prover/smt/solver/model-macro-solver.ts +60 -114
  354. package/src/prover/smt/solver/model-printer.ts +214 -0
  355. package/src/prover/smt/solver/mpf.ts +709 -0
  356. package/src/prover/smt/solver/mus.ts +50 -0
  357. package/src/prover/smt/solver/muz/dl-context.ts +382 -0
  358. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  359. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  360. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  361. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  362. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  363. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  364. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  365. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  366. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  367. package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
  368. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  369. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  370. package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
  371. package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
  372. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  373. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  374. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  375. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  376. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  377. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  378. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  379. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  380. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  381. package/src/prover/smt/solver/nlqsat.ts +484 -0
  382. package/src/prover/smt/solver/nlsat/algebraic.ts +357 -236
  383. package/src/prover/smt/solver/nlsat/atoms.ts +73 -54
  384. package/src/prover/smt/solver/nlsat/evaluator.ts +16 -22
  385. package/src/prover/smt/solver/nlsat/explain.ts +429 -275
  386. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -51
  387. package/src/prover/smt/solver/nlsat/levelwise.ts +477 -344
  388. package/src/prover/smt/solver/nlsat/mpbq.ts +47 -14
  389. package/src/prover/smt/solver/nlsat/polynomial.ts +2385 -832
  390. package/src/prover/smt/solver/nlsat/solver.ts +297 -156
  391. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  392. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  393. package/src/prover/smt/solver/nlsat/types.ts +0 -9
  394. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -51
  395. package/src/prover/smt/solver/nlsat/upolynomial.ts +49 -109
  396. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  397. package/src/prover/smt/solver/nnf.ts +112 -61
  398. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  399. package/src/prover/smt/solver/occf.ts +97 -0
  400. package/src/prover/smt/solver/opt-context.ts +801 -0
  401. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  402. package/src/prover/smt/solver/opt-pareto.ts +301 -0
  403. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  404. package/src/prover/smt/solver/opt-solver.ts +312 -0
  405. package/src/prover/smt/solver/opt-value.ts +55 -0
  406. package/src/prover/smt/solver/optsmt.ts +692 -0
  407. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  408. package/src/prover/smt/solver/pattern-inference.ts +21 -26
  409. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  410. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  411. package/src/prover/smt/solver/poly-rewriter.ts +261 -79
  412. package/src/prover/smt/solver/probes.ts +577 -0
  413. package/src/prover/smt/solver/propagate-values.ts +37 -30
  414. package/src/prover/smt/solver/proto-model.ts +650 -66
  415. package/src/prover/smt/solver/pull-quant.ts +28 -23
  416. package/src/prover/smt/solver/purify-arith.ts +632 -0
  417. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  418. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  419. package/src/prover/smt/solver/qe-lite-der.ts +2 -31
  420. package/src/prover/smt/solver/qe-lite-fm.ts +4 -28
  421. package/src/prover/smt/solver/qe-lite.ts +41 -51
  422. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  423. package/src/prover/smt/solver/qe.ts +1499 -0
  424. package/src/prover/smt/solver/qel.ts +25 -0
  425. package/src/prover/smt/solver/qi-queue.ts +0 -16
  426. package/src/prover/smt/solver/qsat.ts +829 -0
  427. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  428. package/src/prover/smt/solver/quant-tactics.ts +17 -74
  429. package/src/prover/smt/solver/quantifier-analyzer.ts +26 -47
  430. package/src/prover/smt/solver/quantifier-manager.ts +22 -32
  431. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  432. package/src/prover/smt/solver/random-gen.ts +0 -2
  433. package/src/prover/smt/solver/rational.ts +45 -8
  434. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  435. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  436. package/src/prover/smt/solver/reduce-args.ts +225 -0
  437. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  438. package/src/prover/smt/solver/ref-vector.ts +0 -6
  439. package/src/prover/smt/solver/relevancy.ts +2 -16
  440. package/src/prover/smt/solver/rewriter-tpl.ts +59 -135
  441. package/src/prover/smt/solver/rewriter.ts +507 -144
  442. package/src/prover/smt/solver/rlimit.ts +46 -24
  443. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  444. package/src/prover/smt/solver/sat/big.ts +177 -0
  445. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  446. package/src/prover/smt/solver/sat/clause.ts +203 -0
  447. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  448. package/src/prover/smt/solver/sat/config.ts +122 -0
  449. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  450. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  451. package/src/prover/smt/solver/sat/goal2sat.ts +579 -0
  452. package/src/prover/smt/solver/sat/inc-sat-solver.ts +464 -0
  453. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  454. package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
  455. package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
  456. package/src/prover/smt/solver/sat/probing.ts +170 -0
  457. package/src/prover/smt/solver/sat/sat-tactic.ts +53 -0
  458. package/src/prover/smt/solver/sat/sat2goal.ts +189 -0
  459. package/src/prover/smt/solver/sat/scc.ts +142 -0
  460. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  461. package/src/prover/smt/solver/sat/solver.ts +2107 -0
  462. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  463. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  464. package/src/prover/smt/solver/search-tree.ts +284 -0
  465. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  466. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  467. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  468. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  469. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  470. package/src/prover/smt/solver/seq-factory.ts +89 -0
  471. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  472. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  473. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  474. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  475. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  476. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  477. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  478. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  479. package/src/prover/smt/solver/seq-subset.ts +165 -0
  480. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  481. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  482. package/src/prover/smt/solver/smt-kernel.ts +124 -0
  483. package/src/prover/smt/solver/smt-logics.ts +66 -0
  484. package/src/prover/smt/solver/smt-setup.ts +589 -0
  485. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  486. package/src/prover/smt/solver/smtlib-parser.ts +3546 -406
  487. package/src/prover/smt/solver/smtlib-script.ts +2134 -0
  488. package/src/prover/smt/solver/solve-eqs.ts +928 -0
  489. package/src/prover/smt/solver/solver.ts +135 -40
  490. package/src/prover/smt/solver/sort.ts +1 -5
  491. package/src/prover/smt/solver/static-features.ts +314 -0
  492. package/src/prover/smt/solver/sticky-generations.ts +0 -6
  493. package/src/prover/smt/solver/tactic.ts +2141 -0
  494. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  495. package/src/prover/smt/solver/theory-array.ts +1240 -0
  496. package/src/prover/smt/solver/theory-bv.ts +1210 -0
  497. package/src/prover/smt/solver/theory-char.ts +355 -0
  498. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  499. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  500. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  501. package/src/prover/smt/solver/theory-lra-axioms.ts +55 -25
  502. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -11
  503. package/src/prover/smt/solver/theory-lra-final-check.ts +60 -91
  504. package/src/prover/smt/solver/theory-lra-internalize.ts +96 -53
  505. package/src/prover/smt/solver/theory-lra-model.ts +23 -53
  506. package/src/prover/smt/solver/theory-lra-propagate.ts +34 -42
  507. package/src/prover/smt/solver/theory-lra-state.ts +7 -28
  508. package/src/prover/smt/solver/theory-lra.ts +189 -9
  509. package/src/prover/smt/solver/theory-pb.ts +951 -0
  510. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  511. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  512. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  513. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  514. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  515. package/src/prover/smt/solver/theory-seq.ts +961 -0
  516. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  517. package/src/prover/smt/solver/theory.ts +189 -0
  518. package/src/prover/smt/solver/tseitin-cnf.ts +486 -0
  519. package/src/prover/smt/solver/var-subst.ts +37 -39
  520. package/src/prover/smt/table.ts +3 -10
  521. package/src/prover/smt/types.ts +146 -0
  522. package/src/prover/tlapm/cache.ts +74 -48
  523. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  524. package/src/prover/tlapm/tlapm.ts +21 -20
  525. package/src/prover/tlapm-library.ts +3208 -0
  526. package/src/prover/verdict.ts +9 -2
  527. package/src/prover/zenon/check/check.ts +1 -11
  528. package/src/prover/zenon/check/definitions.ts +5 -15
  529. package/src/prover/zenon/check/equality.ts +0 -8
  530. package/src/prover/zenon/check/functions.ts +0 -4
  531. package/src/prover/zenon/check/keys.ts +0 -7
  532. package/src/prover/zenon/check/propositional.ts +0 -3
  533. package/src/prover/zenon/check/records.ts +1 -6
  534. package/src/prover/zenon/check/relations.ts +2 -14
  535. package/src/prover/zenon/check/rewrites.ts +2 -21
  536. package/src/prover/zenon/check/sets.ts +40 -61
  537. package/src/prover/zenon/check/terms.ts +1 -19
  538. package/src/prover/zenon/check/tla.ts +0 -6
  539. package/src/prover/zenon/decide.ts +10 -19
  540. package/src/prover/zenon/encode.ts +0 -9
  541. package/src/prover/zenon/eqrel.ts +2 -15
  542. package/src/prover/zenon/equality-rules.ts +24 -6
  543. package/src/prover/zenon/expr.ts +29 -28
  544. package/src/prover/zenon/index-table.ts +33 -61
  545. package/src/prover/zenon/isar-case.ts +9 -21
  546. package/src/prover/zenon/isar.ts +37 -67
  547. package/src/prover/zenon/limits.ts +0 -4
  548. package/src/prover/zenon/llproof.ts +2 -22
  549. package/src/prover/zenon/mltoll.ts +66 -106
  550. package/src/prover/zenon/node.ts +20 -15
  551. package/src/prover/zenon/ocaml.ts +1 -17
  552. package/src/prover/zenon/parse.ts +9 -13
  553. package/src/prover/zenon/phrase.ts +2 -14
  554. package/src/prover/zenon/proof.ts +0 -11
  555. package/src/prover/zenon/propositional-rules.ts +0 -7
  556. package/src/prover/zenon/rules.ts +3 -8
  557. package/src/prover/zenon/search.ts +11 -35
  558. package/src/prover/zenon/tla/functions.ts +59 -33
  559. package/src/prover/zenon/tla/llproof.ts +67 -78
  560. package/src/prover/zenon/tla/records.ts +57 -35
  561. package/src/prover/zenon/tla/rewrites.ts +12 -21
  562. package/src/prover/zenon/tla/sets.ts +88 -59
  563. package/src/prover/zenon/tla/terms.ts +0 -8
  564. package/src/prover/zenon/tla/tla.ts +66 -66
  565. package/src/randomization.ts +81 -35
  566. package/src/resolve.ts +1132 -430
  567. package/src/runtime.ts +33 -23
  568. package/src/sany/builtins.ts +11 -14
  569. package/src/sany/generation.ts +383 -0
  570. package/src/sany/generator-def-entries.ts +210 -0
  571. package/src/sany/generator-definitions.ts +688 -0
  572. package/src/sany/generator-expressions.ts +1108 -0
  573. package/src/sany/generator-proofs.ts +665 -0
  574. package/src/sany/generator.ts +192 -2764
  575. package/src/sany/levels.ts +5 -35
  576. package/src/sany/lexer.ts +61 -80
  577. package/src/sany/linter.ts +0 -10
  578. package/src/sany/modules.ts +5 -7
  579. package/src/sany/nodes.ts +6 -44
  580. package/src/sany/parse-error.ts +39 -117
  581. package/src/sany/report.ts +32 -69
  582. package/src/sany/selectors.ts +60 -82
  583. package/src/sany/source.ts +1 -17
  584. package/src/sany/xml.ts +37 -120
  585. package/src/search.ts +913 -227
  586. package/src/simulate.ts +765 -0
  587. package/src/spec-description.ts +198 -104
  588. package/src/standard-definitions.ts +4 -4
  589. package/src/standard-modules.ts +302 -99
  590. package/src/state-graph.ts +52 -33
  591. package/src/subexpressions.ts +578 -166
  592. package/src/substitution-levels.ts +7 -7
  593. package/src/successors.ts +299 -108
  594. package/src/symmetry.ts +37 -28
  595. package/src/tableau.ts +29 -26
  596. package/src/tlc/fingerprint.ts +267 -79
  597. package/src/tlc/jar-data.ts +122 -6
  598. package/src/tlc/messages.ts +127 -56
  599. package/src/tlc/order.ts +53 -72
  600. package/src/tlc/random.ts +38 -49
  601. package/src/tlc/replay.ts +579 -230
  602. package/src/tlc/summary.ts +64 -60
  603. package/src/tlc/tlc-operators.ts +83 -47
  604. package/src/tlc/tlcext-operators.ts +205 -127
  605. package/src/tlc/trace-spec.ts +235 -0
  606. package/src/tlc/value-stream.ts +139 -0
  607. package/src/tlc/version.ts +1 -4
  608. package/src/trace-liveness.ts +529 -0
  609. package/src/transfer.ts +22 -25
  610. package/src/typed-tier.ts +6556 -0
  611. package/src/typescript/actions.ts +479 -0
  612. package/src/typescript/collections.ts +614 -0
  613. package/src/typescript/compile.ts +63 -0
  614. package/src/typescript/context.ts +94 -0
  615. package/src/typescript/emit.ts +121 -0
  616. package/src/typescript/expressions.ts +496 -0
  617. package/src/typescript/formula.ts +154 -0
  618. package/src/typescript/functions.ts +284 -0
  619. package/src/typescript/model.ts +162 -0
  620. package/src/typescript/names.ts +114 -0
  621. package/src/typescript/program.ts +48 -0
  622. package/src/typescript/properties.ts +139 -0
  623. package/src/typescript/scope.ts +112 -0
  624. package/src/typescript/steps.ts +167 -0
  625. package/src/typescript/types.ts +171 -0
  626. package/src/values.ts +945 -526
  627. package/src/worker.ts +7 -8
  628. package/src/prover/isabelle/isar/statement.ts +0 -57
  629. package/src/prover/smt/solver/z3-license.txt +0 -10
  630. package/src/prover/tlaps-module.ts +0 -510
  631. package/src/prover/zenon/LICENSE +0 -32
@@ -1,10 +1,11 @@
1
1
  import { TlaEvaluationError } from "./errors";
2
+ import { isExpressionImpure } from "./dependencies";
2
3
  import { hasRepeatedEffects, type Environment } from "./evaluate";
3
4
  import {
4
- createTautologyError,
5
- evaluateLive,
6
5
  evaluateOnLasso,
6
+ getInterpretedAtoms,
7
7
  toLiveExpression,
8
+ type LiveAtoms,
8
9
  type ScopedExpression,
9
10
  type TemporalProperty,
10
11
  } from "./liveness";
@@ -14,30 +15,30 @@ import {
14
15
  getSolutions,
15
16
  getTermKey,
16
17
  isFulfilling,
18
+ type LiveAction,
19
+ type LiveEnabled,
17
20
  type LiveExpression,
21
+ type LiveState,
18
22
  type Solution,
19
23
  type Tableau,
20
24
  } from "./tableau";
25
+ import { findTraceLasso, type TraceLasso } from "./trace-liveness";
21
26
  import { isSameValue, type Value } from "./values";
22
27
 
23
- export interface LiveSuccessor {
28
+ export interface LiveSuccessor<State = Value[]> {
24
29
  index: number;
25
- state: Value[];
30
+ state: State;
26
31
  }
27
32
 
28
33
  export interface Lasso {
29
34
  prefix: number[];
30
35
  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
36
  isCycleConstrained: boolean;
34
37
  }
35
38
 
36
39
  export interface LivenessChecker {
37
- // How many solutions of the negated properties TLC checks, which it calls branches.
38
40
  branches: number;
39
- // With a tracing environment, the checks record their call stack as TLC's replay of a failed
40
- // check does.
41
+ solutions: Solution[];
41
42
  addInitialState: (index: number, state: Value[], tracing?: Environment) => void;
42
43
  addState: (
43
44
  index: number,
@@ -45,46 +46,101 @@ export interface LivenessChecker {
45
46
  successors: LiveSuccessor[],
46
47
  tracing?: Environment,
47
48
  ) => number[] | undefined;
49
+ storeState: (pending: number, index: number) => void;
50
+ getStateCounts: () => number[];
48
51
  findViolation: () => Lasso | undefined;
49
52
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
50
53
  }
51
54
 
52
- interface SearchGraph {
53
- getFingerprint: (successor: LiveSuccessor) => number;
54
- getSuccessors: (index: number, state: Value[]) => LiveSuccessor[];
55
+ export interface TraceViolation extends TraceLasso {
56
+ properties: string[];
57
+ failures: TlaEvaluationError[];
58
+ }
59
+
60
+ export interface LivenessChecks {
61
+ solutions: Solution[];
62
+ findTraceViolation: (trace: Value[][], fingerprints: bigint[]) => TraceViolation | undefined;
63
+ }
64
+
65
+ export interface LiveGraph<State> {
66
+ branches: number;
67
+ addInitialState: (index: number, state: State) => void;
68
+ // The path to an accepting node the state reaches, if any.
69
+ addState: (
70
+ index: number,
71
+ state: State,
72
+ successors: LiveSuccessor<State>[],
73
+ isRerun?: boolean,
74
+ ) => number[] | undefined;
75
+ storeState: (pending: number, index: number) => void;
76
+ getStateCounts: () => number[];
77
+ findViolation: () => Lasso | undefined;
78
+ }
79
+
80
+ export interface SearchGraph<State> {
81
+ getFingerprint: (successor: LiveSuccessor<State>) => number;
82
+ forEachActionSuccessors: (
83
+ index: number,
84
+ state: State,
85
+ onSuccessors: (successors: LiveSuccessor<State>[]) => void,
86
+ replay?: Environment,
87
+ ) => void;
88
+ }
89
+
90
+ interface Tracing {
91
+ atoms: LiveAtoms<Value[]>;
92
+ replay: Environment | undefined;
93
+ }
94
+
95
+ export interface LiveEvaluation<State> {
96
+ atoms: LiveAtoms<State>;
97
+ // Whether a check's result for a state holds for every step from it.
98
+ isShared: boolean;
99
+ isSame: (left: State, right: State) => boolean;
100
+ // Evaluates the checks of a state the search found from the state at source.
101
+ evaluateFrom: <Result>(source: number | undefined, evaluate: () => Result) => Result;
55
102
  }
56
103
 
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
104
  interface Pool<Data extends Int32Array | Uint8Array> {
60
105
  data: Data;
61
106
  length: number;
62
107
  create: (length: number) => Data;
63
108
  }
64
109
 
65
- // TLC's behavior graph for one solution: a node per state, or per state and tableau node.
66
- interface BehaviorGraph {
110
+ // A check reads and fills the state atoms of a state in its row, which starts at offset.
111
+ type Check<State> = (
112
+ state: State,
113
+ row: Int8Array,
114
+ offset: number,
115
+ next: State | undefined,
116
+ ) => boolean;
117
+
118
+ interface BehaviorChecks<State> {
119
+ states: Check<State>[];
120
+ actions: Check<State>[];
121
+ // The state predicates of each tableau node, or, where its checks share results and it has only
122
+ // state atoms and their negations, each atom's id * 2 plus 1 if it must hold.
123
+ nodes: (Check<State>[] | Int32Array)[];
124
+ }
125
+
126
+ interface BehaviorGraph<State> {
67
127
  solution: Solution;
68
- // One id per distinct action check across the solutions.
128
+ checks: BehaviorChecks<State>;
69
129
  actionIds: Int32Array;
70
130
  nodeStates: number[];
71
131
  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
132
  edgeStarts: number[];
75
133
  edgeCounts: number[];
76
134
  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
135
  edgeActions: Pool<Uint8Array>;
80
136
  stateResults: Pool<Uint8Array>;
81
137
  initial: number[];
82
- // The nodes of each state in the order they are recorded, a list through nextSiblings.
83
138
  firstNodes: Pool<Int32Array>;
84
139
  lastNodes: Pool<Int32Array>;
85
140
  nextSiblings: number[];
86
141
  nodeIds: NodeTable;
87
142
  isDone: boolean[];
143
+ stateCount: number;
88
144
  errorNode: number | undefined;
89
145
  }
90
146
 
@@ -104,15 +160,14 @@ const containsAlways = (expression: LiveExpression): boolean => {
104
160
  }
105
161
  };
106
162
 
107
- // TLC's OrderOfSolution#hasEmptyPEMAndBoxFreePromises, negated.
163
+ const isEmptyModel = (model: Solution["models"][number]) =>
164
+ model.eventuallyAlways.length === 0 &&
165
+ model.infinitelyOftenStates.length === 0 &&
166
+ model.infinitelyOftenActions.length === 0;
167
+
108
168
  const isCycleConstrained = (solution: Solution) =>
109
169
  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
- );
170
+ solution.models.some((model) => !isEmptyModel(model));
116
171
 
117
172
  const isSameState = (left: Value[], right: Value[]) =>
118
173
  left.every((value, position) => isSameValue(value, right[position]));
@@ -128,21 +183,24 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
128
183
  pool: Pool<Data>,
129
184
  offset: number,
130
185
  values: ArrayLike<number>,
186
+ start = 0,
187
+ length = values.length - start,
131
188
  ) => {
132
- const end = offset + values.length;
189
+ const end = offset + length;
133
190
  if (end > pool.data.length) {
134
191
  const data = pool.create(Math.max(2 * pool.data.length, end));
135
192
  data.set(pool.data);
136
193
  pool.data = data;
137
194
  }
138
- pool.data.set(values, offset);
195
+ for (let position = 0; position < length; position++) {
196
+ pool.data[offset + position] = values[start + position];
197
+ }
139
198
  pool.length = Math.max(pool.length, end);
140
199
  };
141
200
 
142
201
  const NO_NODE = -1;
143
202
 
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.
203
+ // 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
204
  interface NodeTable {
147
205
  slots: Int32Array;
148
206
  size: number;
@@ -165,21 +223,20 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
165
223
 
166
224
  const UNWRITTEN = -1;
167
225
 
168
- const isWritten = (behavior: BehaviorGraph, node: number) =>
226
+ const isWritten = <State>(behavior: BehaviorGraph<State>, node: number) =>
169
227
  (behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
170
228
 
171
- const getNodeSuccessors = (behavior: BehaviorGraph, node: number) => {
229
+ const getNodeSuccessors = <State>(behavior: BehaviorGraph<State>, node: number) => {
172
230
  const start = behavior.edgeStarts[node];
173
231
  return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
174
232
  };
175
233
 
176
- const getStateResult = (behavior: BehaviorGraph, node: number, position: number) =>
234
+ const getStateResult = <State>(behavior: BehaviorGraph<State>, node: number, position: number) =>
177
235
  behavior.stateResults.data[
178
236
  behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
179
237
  ] === 1;
180
238
 
181
- // A node owns one entry in each per-node array of its graph.
182
- const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
239
+ const pushNode = <State>(behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
183
240
  behavior.nodeStates.push(state);
184
241
  behavior.nodeTableaux.push(tableauNode);
185
242
  behavior.edgeStarts.push(UNWRITTEN);
@@ -188,7 +245,7 @@ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) =
188
245
  return behavior.nodeStates.length - 1;
189
246
  };
190
247
 
191
- const getStateNodes = (behavior: BehaviorGraph, state: number) => {
248
+ const getStateNodes = <State>(behavior: BehaviorGraph<State>, state: number) => {
192
249
  const nodes: number[] = [];
193
250
  for (
194
251
  let node = behavior.firstNodes.data[state] ?? NO_NODE;
@@ -208,34 +265,315 @@ const UNVISITED = -1;
208
265
 
209
266
  const MAXIMUM_LINK = Number.MAX_SAFE_INTEGER;
210
267
 
211
- export const createLivenessChecker = (
268
+ const getLiveFormula = (
212
269
  properties: TemporalProperty[],
213
270
  temporals: ScopedExpression[],
214
271
  environment: Environment,
215
- search: SearchGraph,
216
- ): LivenessChecker | undefined => {
217
- if (properties.length === 0) return undefined;
272
+ ) => {
218
273
  const fairness = temporals.map((item) =>
219
274
  toLiveExpression(item.expression, item.scope, environment),
220
275
  );
221
- const negations = properties.map((property) =>
222
- createUnary("Not", toLiveExpression(property.expression, property.scope, environment)),
276
+ const checks = properties.map((property) =>
277
+ toLiveExpression(property.expression, property.scope, environment),
223
278
  );
279
+ const negations = checks.map((check) => createUnary("Not", check));
224
280
  const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
225
281
  const formula =
226
282
  fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
227
- const solutions = getSolutions(formula);
228
- if (solutions.length === 0) {
229
- throw createTautologyError();
283
+ return { formula, checks };
284
+ };
285
+
286
+ export type LiveAtom = LiveState | LiveEnabled | LiveAction;
287
+
288
+ const getAtomExpressions = (atom: LiveAtom): ScopedExpression[] => {
289
+ switch (atom.kind) {
290
+ case "State":
291
+ return [atom];
292
+ case "Enabled":
293
+ return [{ expression: atom.step, scope: atom.scope }];
294
+ case "Action":
295
+ return [atom.expression, atom.subscript].flatMap((inner) =>
296
+ inner ? [{ expression: inner, scope: atom.scope }] : [],
297
+ );
230
298
  }
299
+ };
300
+
301
+ const collectAtoms = (expression: LiveExpression, atoms: Set<LiveAtom>) => {
302
+ switch (expression.kind) {
303
+ case "Boolean":
304
+ return;
305
+ case "State":
306
+ case "Enabled":
307
+ case "Action":
308
+ atoms.add(expression);
309
+ return;
310
+ case "And":
311
+ case "Or":
312
+ expression.operands.forEach((operand) => collectAtoms(operand, atoms));
313
+ return;
314
+ default:
315
+ collectAtoms(expression.body, atoms);
316
+ }
317
+ };
318
+
319
+ // The atoms the checks of the solutions evaluate.
320
+ export const getLiveAtoms = (solutions: Solution[]) => {
321
+ const atoms = new Set<LiveAtom>();
322
+ for (const solution of solutions) {
323
+ [
324
+ ...solution.stateChecks,
325
+ ...solution.actionChecks,
326
+ ...(solution.tableau?.nodes.flatMap((node) => node.statePredicates) ?? []),
327
+ ].forEach((check) => collectAtoms(check, atoms));
328
+ }
329
+ return [...atoms];
330
+ };
331
+
332
+ // The expressions the checks of the solutions evaluate.
333
+ export const getLiveExpressions = (solutions: Solution[]) =>
334
+ getLiveAtoms(solutions).flatMap((atom) =>
335
+ getAtomExpressions(atom).map((item) => item.expression),
336
+ );
337
+
338
+ const isSharingResults = (formula: LiveExpression, environment: Environment) => {
339
+ const formulaAtoms = new Set<LiveAtom>();
340
+ collectAtoms(formula, formulaAtoms);
341
+ const checked = [...formulaAtoms].flatMap(getAtomExpressions);
342
+ return checked.every((item) => item.scope === undefined)
343
+ ? !isExpressionImpure(
344
+ checked.map((item) => item.expression),
345
+ environment,
346
+ "repeated",
347
+ )
348
+ : !hasRepeatedEffects(environment);
349
+ };
350
+
351
+ const getViolatedProperties = (
352
+ properties: TemporalProperty[],
353
+ checks: LiveExpression[],
354
+ path: Value[][],
355
+ cycleStart: number,
356
+ environment: Environment,
357
+ failures?: TlaEvaluationError[],
358
+ ) => [
359
+ ...new Set(
360
+ properties
361
+ .filter((_property, position) => {
362
+ try {
363
+ return !evaluateOnLasso(checks[position], path, cycleStart, 0, environment);
364
+ } catch (error) {
365
+ if (!failures || !(error instanceof TlaEvaluationError)) throw error;
366
+ failures.push(error);
367
+ return false;
368
+ }
369
+ })
370
+ .map((property) => property.name),
371
+ ),
372
+ ];
373
+
374
+ export const createLivenessChecks = (
375
+ properties: TemporalProperty[],
376
+ temporals: ScopedExpression[],
377
+ environment: Environment,
378
+ ): LivenessChecks | undefined => {
379
+ if (properties.length === 0) return undefined;
380
+ const live = getLiveFormula(properties, temporals, environment);
381
+ const solutions = getSolutions(live.formula);
382
+ const atoms = getInterpretedAtoms(environment);
383
+ const isShared = isSharingResults(live.formula, environment);
384
+ return {
385
+ solutions,
386
+ findTraceViolation: (trace, fingerprints) => {
387
+ const lasso = findTraceLasso(trace, fingerprints, solutions, atoms, isShared);
388
+ if (!lasso) return undefined;
389
+ // Liveness#findViolatedProperties reports a property it fails to evaluate on the lasso and goes on.
390
+ const failures: TlaEvaluationError[] = [];
391
+ const violated = getViolatedProperties(
392
+ properties,
393
+ live.checks,
394
+ lasso.positions.map((position) => trace[position]),
395
+ lasso.cyclePosition - 1,
396
+ environment,
397
+ failures,
398
+ );
399
+ return { ...lasso, properties: violated, failures };
400
+ },
401
+ };
402
+ };
403
+
404
+ export const createLivenessChecker = (
405
+ properties: TemporalProperty[],
406
+ temporals: ScopedExpression[],
407
+ environment: Environment,
408
+ search: SearchGraph<Value[]>,
409
+ ): LivenessChecker | undefined => {
410
+ if (properties.length === 0) return undefined;
411
+ const live = getLiveFormula(properties, temporals, environment);
412
+ const isShared = isSharingResults(live.formula, environment);
413
+ const solutions = getSolutions(live.formula);
414
+ const tracing: Tracing = { atoms: getInterpretedAtoms(environment), replay: undefined };
415
+ const graph = createLiveGraph(
416
+ solutions,
417
+ {
418
+ atoms: {
419
+ holdsState: (atom, state) => tracing.atoms.holdsState(atom, state),
420
+ holdsAction: (atom, state, next) => tracing.atoms.holdsAction(atom, state, next),
421
+ },
422
+ isShared,
423
+ isSame: isSameState,
424
+ evaluateFrom: (source, evaluate) => {
425
+ environment.runtime.setLivenessSource(source);
426
+ try {
427
+ return evaluate();
428
+ } finally {
429
+ environment.runtime.setLivenessSource(undefined);
430
+ }
431
+ },
432
+ },
433
+ {
434
+ getFingerprint: search.getFingerprint,
435
+ forEachActionSuccessors: (index, state, onSuccessors) =>
436
+ search.forEachActionSuccessors(index, state, onSuccessors, tracing.replay),
437
+ },
438
+ environment.runtime.version !== "1.7.4",
439
+ );
440
+ const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
441
+ if (replay === undefined) return run();
442
+ tracing.atoms = getInterpretedAtoms(replay);
443
+ tracing.replay = replay;
444
+ try {
445
+ return run();
446
+ } finally {
447
+ tracing.atoms = getInterpretedAtoms(environment);
448
+ tracing.replay = undefined;
449
+ }
450
+ };
451
+ return {
452
+ branches: graph.branches,
453
+ solutions,
454
+ addInitialState: (index, state, replay) =>
455
+ traceWith(replay, () => graph.addInitialState(index, state)),
456
+ addState: (index, state, successors, replay) =>
457
+ traceWith(replay, () => graph.addState(index, state, successors, replay !== undefined)),
458
+ storeState: graph.storeState,
459
+ getStateCounts: graph.getStateCounts,
460
+ findViolation: graph.findViolation,
461
+ getViolatedProperties: (path, cycleStart) =>
462
+ getViolatedProperties(properties, live.checks, path, cycleStart, environment),
463
+ };
464
+ };
465
+
466
+ export const createLiveGraph = <State>(
467
+ solutions: Solution[],
468
+ evaluation: LiveEvaluation<State>,
469
+ search: SearchGraph<State>,
470
+ isAcceptingFound: boolean,
471
+ ): LiveGraph<State> => {
231
472
  const actionIds = new Map<string, number>();
232
- const behaviors = solutions.map((solution): BehaviorGraph => ({
473
+ let capacityMultiplier = 1;
474
+ const isShared = evaluation.isShared;
475
+ const atoms = evaluation.atoms;
476
+ const evaluateFrom = evaluation.evaluateFrom;
477
+ const stateAtoms = new Map<LiveState | LiveEnabled, number>();
478
+ const atomsById: (LiveState | LiveEnabled)[] = [];
479
+ const getAtomId = (atom: LiveState | LiveEnabled) => {
480
+ const id = stateAtoms.get(atom) ?? stateAtoms.size;
481
+ stateAtoms.set(atom, id);
482
+ atomsById[id] = atom;
483
+ return id;
484
+ };
485
+ const getLiterals = (expression: LiveExpression): number[] | undefined => {
486
+ if (expression.kind === "State" || expression.kind === "Enabled") {
487
+ return [getAtomId(expression) * 2 + 1];
488
+ }
489
+ if (expression.kind === "Not") {
490
+ const body = expression.body;
491
+ return body.kind === "State" || body.kind === "Enabled" ? [getAtomId(body) * 2] : undefined;
492
+ }
493
+ if (expression.kind !== "And") return undefined;
494
+ const operands = expression.operands.map(getLiterals);
495
+ return operands.every((operand) => operand !== undefined) ? operands.flat() : undefined;
496
+ };
497
+ // The rows of states, one after another, hold whether each state atom holds of a state: 1 or 0,
498
+ // or -1 before it is evaluated.
499
+ const createRows = (count: number) => new Int8Array(count * stateAtoms.size).fill(-1);
500
+ // The edge rows of steps hold the result of each action check, shared by the behaviors that
501
+ // check it.
502
+ const createEdgeRows = (count: number) => new Int8Array(count * actionIds.size).fill(-1);
503
+ // Unless the checks share results, each check evaluates its atoms afresh.
504
+ const runCheck = (
505
+ check: Check<State>,
506
+ state: State,
507
+ row: Int8Array,
508
+ offset: number,
509
+ next?: State,
510
+ ) => (isShared ? check(state, row, offset, next) : check(state, createRows(1), 0, next));
511
+ const compileCheck = (expression: LiveExpression): Check<State> => {
512
+ switch (expression.kind) {
513
+ case "Boolean": {
514
+ const value = expression.value;
515
+ return () => value;
516
+ }
517
+ case "State":
518
+ case "Enabled": {
519
+ const id = getAtomId(expression);
520
+ return (state, row, offset) => {
521
+ if (row[offset + id] === -1) {
522
+ row[offset + id] = atoms.holdsState(expression, state) ? 1 : 0;
523
+ }
524
+ return row[offset + id] === 1;
525
+ };
526
+ }
527
+ case "Action": {
528
+ const enabled = expression.enabled && getAtomId(expression.enabled);
529
+ return (state, row, offset, next) =>
530
+ !(enabled !== undefined && row[offset + enabled] === 0) &&
531
+ next !== undefined &&
532
+ atoms.holdsAction(expression, state, next);
533
+ }
534
+ case "Not": {
535
+ const body = compileCheck(expression.body);
536
+ return (state, row, offset, next) => !body(state, row, offset, next);
537
+ }
538
+ case "And": {
539
+ const operands = expression.operands.map(compileCheck);
540
+ return (state, row, offset, next) =>
541
+ operands.every((operand) => operand(state, row, offset, next));
542
+ }
543
+ case "Or": {
544
+ const operands = expression.operands.map(compileCheck);
545
+ return (state, row, offset, next) =>
546
+ operands.some((operand) => operand(state, row, offset, next));
547
+ }
548
+ case "Next": {
549
+ const body = compileCheck(expression.body);
550
+ return (state, _row, _offset, next) => body(next ?? state, createRows(1), 0, undefined);
551
+ }
552
+ case "Always":
553
+ case "Eventually":
554
+ return () => {
555
+ throw new TlaEvaluationError("TLC cannot evaluate a temporal formula in a single step");
556
+ };
557
+ }
558
+ };
559
+ const behaviors = solutions.map((solution): BehaviorGraph<State> => ({
233
560
  solution,
561
+ checks: {
562
+ states: solution.stateChecks.map(compileCheck),
563
+ actions: solution.actionChecks.map(compileCheck),
564
+ nodes:
565
+ solution.tableau?.nodes.map((node) => {
566
+ const literals = isShared
567
+ ? getLiterals({ kind: "And", operands: node.statePredicates })
568
+ : undefined;
569
+ return literals ? Int32Array.from(literals) : node.statePredicates.map(compileCheck);
570
+ }) ?? [],
571
+ },
234
572
  actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
235
573
  const key = getTermKey(predicate);
236
- const id = actionIds.get(key) ?? actionIds.size;
237
- actionIds.set(key, id);
238
- return id;
574
+ const actionId = actionIds.get(key) ?? actionIds.size;
575
+ actionIds.set(key, actionId);
576
+ return actionId;
239
577
  }),
240
578
  nodeStates: [],
241
579
  nodeTableaux: [],
@@ -250,90 +588,88 @@ export const createLivenessChecker = (
250
588
  nextSiblings: [],
251
589
  nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
252
590
  isDone: [],
591
+ stateCount: 0,
253
592
  errorNode: undefined,
254
593
  }));
255
- const capacity = { multiplier: 1 };
256
-
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
- 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
- };
265
- const getStateCache = (state: Value[]) => {
266
- const cache = shared.states.get(state) ?? new Map<LiveExpression, boolean>();
267
- shared.states.set(state, cache);
268
- return cache;
269
- };
270
- // TLCGet("level") reads the level of the state whose successors the checks run on.
271
- const evaluateFrom = <Result>(source: number | undefined, evaluate: () => Result) => {
272
- environment.runtime.setLivenessSource(source);
273
- const result = evaluate();
274
- environment.runtime.setLivenessSource(undefined);
275
- return result;
276
- };
277
- const evaluateState = (predicate: LiveExpression, state: Value[]) =>
278
- evaluateLive(
279
- predicate,
280
- state,
281
- undefined,
282
- evaluation.environment,
283
- isShared ? getStateCache(state) : new Map(),
284
- );
285
- const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
286
- evaluateFrom(source, () =>
287
- Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
288
- evaluateState(predicate, state) ? 1 : 0,
289
- ),
290
- );
594
+ const checkState = (
595
+ behavior: BehaviorGraph<State>,
596
+ source: number,
597
+ state: State,
598
+ row: Int8Array,
599
+ offset: number,
600
+ ) =>
601
+ evaluateFrom(source, () => {
602
+ const checks = behavior.checks.states;
603
+ const results = new Uint8Array(checks.length);
604
+ checks.forEach((check, position) => {
605
+ results[position] = runCheck(check, state, row, offset) ? 1 : 0;
606
+ });
607
+ return results;
608
+ });
609
+ // Writes the result of each action check of the step to successor at resultOffset in results.
291
610
  const checkAction = (
292
- behavior: BehaviorGraph,
611
+ behavior: BehaviorGraph<State>,
293
612
  source: number,
294
- state: Value[],
295
- successor: Value[],
613
+ state: State,
614
+ row: Int8Array,
615
+ offset: number,
616
+ successor: State,
617
+ edges: Int8Array,
618
+ edgeOffset: number,
619
+ results: Uint8Array,
620
+ resultOffset: number,
296
621
  ) =>
297
622
  evaluateFrom(source, () => {
298
- const predicates = behavior.solution.actionChecks;
299
- if (!isShared) {
300
- return Uint8Array.from(predicates, (predicate) =>
301
- evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
302
- );
303
- }
304
- const stateCache = getStateCache(state);
305
- const results = shared.actions.get(state) ?? new Map<Value[], Int8Array>();
306
- shared.actions.set(state, results);
307
- const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
308
- results.set(successor, known);
309
- return Uint8Array.from(behavior.actionIds, (id, position) => {
310
- if (known[id] === -1) {
311
- known[id] = evaluateLive(
312
- predicates[position],
623
+ const actions = behavior.checks.actions;
624
+ for (let position = 0; position < actions.length; position++) {
625
+ if (!isShared) {
626
+ results[resultOffset + position] = runCheck(
627
+ actions[position],
313
628
  state,
629
+ row,
630
+ offset,
314
631
  successor,
315
- evaluation.environment,
316
- stateCache,
317
632
  )
318
633
  ? 1
319
634
  : 0;
635
+ continue;
320
636
  }
321
- return known[id];
322
- });
637
+ const edge = edgeOffset + behavior.actionIds[position];
638
+ if (edges[edge] === -1)
639
+ edges[edge] = actions[position](state, row, offset, successor) ? 1 : 0;
640
+ results[resultOffset + position] = edges[edge];
641
+ }
323
642
  });
643
+ const holdsNode = (
644
+ behavior: BehaviorGraph<State>,
645
+ node: number,
646
+ state: State,
647
+ row: Int8Array,
648
+ offset: number,
649
+ ) => {
650
+ const checks = behavior.checks.nodes[node];
651
+ if (!(checks instanceof Int32Array)) {
652
+ return checks.every((check) => runCheck(check, state, row, offset));
653
+ }
654
+ for (let position = 0; position < checks.length; position++) {
655
+ const literal: number = checks[position];
656
+ const cell = offset + (literal >> 1);
657
+ if (row[cell] === -1) row[cell] = atoms.holdsState(atomsById[literal >> 1], state) ? 1 : 0;
658
+ if (row[cell] !== (literal & 1)) return false;
659
+ }
660
+ return true;
661
+ };
324
662
  const isConsistent = (
325
- tableau: Tableau,
663
+ behavior: BehaviorGraph<State>,
326
664
  node: number,
327
665
  source: number | undefined,
328
- state: Value[],
329
- ) =>
330
- evaluateFrom(source, () =>
331
- tableau.nodes[node].statePredicates.every((predicate) => evaluateState(predicate, state)),
332
- );
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.
666
+ state: State,
667
+ row: Int8Array,
668
+ offset: number,
669
+ ) => evaluateFrom(source, () => holdsNode(behavior, node, state, row, offset));
670
+
335
671
  const isAccepting = (tableau: Tableau, node: number) => {
336
- if (environment.runtime.version === "1.7.4") return false;
672
+ if (!isAcceptingFound) return false;
337
673
  const tableauNode = tableau.nodes[node];
338
674
  return (
339
675
  tableauNode.particle.length === 0 &&
@@ -341,22 +677,19 @@ export const createLivenessChecker = (
341
677
  tableauNode.successors[0] === node
342
678
  );
343
679
  };
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
680
 
352
- const getNodeId = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
681
+ const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
353
682
  if (!behavior.solution.tableau) return state;
354
683
  const slots = behavior.nodeIds.slots;
355
684
  const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
356
685
  return slots[slot] === 0 ? undefined : slots[slot + 2];
357
686
  };
358
- const recordNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
359
- const node = pushNode(behavior, state, tableauNode);
687
+ const linkNode = (
688
+ behavior: BehaviorGraph<State>,
689
+ state: number,
690
+ tableauNode: number,
691
+ node: number,
692
+ ) => {
360
693
  const table = behavior.nodeIds;
361
694
  if (++table.size * 2 > table.slots.length / 3) {
362
695
  const old = table.slots;
@@ -372,24 +705,43 @@ export const createLivenessChecker = (
372
705
  }
373
706
  }
374
707
  table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
708
+ if (state < 0) return node;
375
709
  const last = behavior.lastNodes.data[state] ?? NO_NODE;
376
710
  if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
377
711
  else behavior.nextSiblings[last] = node;
378
712
  writeToPool(behavior.lastNodes, state, [node]);
379
713
  return node;
380
714
  };
715
+ const hasState = (behavior: BehaviorGraph<State>, state: number) =>
716
+ state < 0
717
+ ? behavior.checks.nodes.some(
718
+ (_checks, tableauNode) => getNodeId(behavior, state, tableauNode) !== undefined,
719
+ )
720
+ : behavior.isDone[state] === true || (behavior.firstNodes.data[state] ?? NO_NODE) !== NO_NODE;
721
+ const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
722
+ if (!hasState(behavior, state)) behavior.stateCount++;
723
+ return linkNode(behavior, state, tableauNode, pushNode(behavior, state, tableauNode));
724
+ };
725
+ // The action results of the edge to each target are at its position in actions.
381
726
  const writeNode = (
382
- behavior: BehaviorGraph,
727
+ behavior: BehaviorGraph<State>,
383
728
  node: number,
384
729
  targets: number[],
385
- actions: Uint8Array[],
730
+ actionResults: Uint8Array,
731
+ actions: number[],
386
732
  stateResults: Uint8Array,
387
733
  ) => {
388
734
  const start = behavior.edgeTargets.length;
389
735
  const actionCount = behavior.solution.actionChecks.length;
390
736
  writeToPool(behavior.edgeTargets, start, targets);
391
- actions.forEach((results, position) =>
392
- writeToPool(behavior.edgeActions, (start + position) * actionCount, results),
737
+ actions.forEach((position, edge) =>
738
+ writeToPool(
739
+ behavior.edgeActions,
740
+ (start + edge) * actionCount,
741
+ actionResults,
742
+ position * actionCount,
743
+ actionCount,
744
+ ),
393
745
  );
394
746
  writeToPool(
395
747
  behavior.stateResults,
@@ -400,67 +752,73 @@ export const createLivenessChecker = (
400
752
  behavior.edgeCounts[node] = targets.length;
401
753
  };
402
754
 
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.
406
- 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
- };
413
- const insertSuccessor = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
755
+ // 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.
756
+ // Each slot holds a candidate's position plus one, or 0 when it is empty.
757
+ const successorSet = { slots: new Int32Array(0) };
758
+ const getSuccessorSet = (index: number, state: State, successors: LiveSuccessor<State>[]) => {
759
+ const candidates = [...successors, { index, state }];
760
+ const capacity = SUCCESSOR_CAPACITY * capacityMultiplier;
761
+ successorSet.slots =
762
+ successorSet.slots.length === capacity
763
+ ? successorSet.slots.fill(0)
764
+ : new Int32Array(capacity);
765
+ const insert = (position: number) => {
766
+ const slots = successorSet.slots;
767
+ const candidate = candidates[position];
414
768
  for (
415
- let slot = (search.getFingerprint(successor) & 0x7fffffff) % slots.length;
769
+ let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
416
770
  ;
417
771
  slot = (slot + 1) % slots.length
418
772
  ) {
419
773
  const entry = slots[slot];
420
- if (entry === undefined) {
421
- slots[slot] = successor;
774
+ if (entry === 0) {
775
+ slots[slot] = position + 1;
422
776
  return true;
423
777
  }
424
- if (entry.index === successor.index && isSameState(entry.state, successor.state))
778
+ const stored = candidates[entry - 1];
779
+ if (stored.index === candidate.index && evaluation.isSame(stored.state, candidate.state))
425
780
  return false;
426
781
  }
427
782
  };
428
- 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);
783
+ let count = 0;
784
+ for (let position = 0; position < candidates.length; position++) {
785
+ if (count >= successorSet.slots.length >> 1) {
786
+ const old = successorSet.slots;
787
+ successorSet.slots = new Int32Array(2 * old.length + 1);
788
+ for (const entry of old) if (entry !== 0) insert(entry - 1);
433
789
  }
434
- if (insertSuccessor(table.slots, successor)) table.count++;
435
- };
436
- successors.forEach(addSuccessor);
437
- 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);
790
+ if (insert(position)) count++;
791
+ }
792
+ if (successorSet.slots.length > capacity) capacityMultiplier++;
793
+ const set: LiveSuccessor<State>[] = [];
794
+ for (const entry of successorSet.slots) if (entry !== 0) set.push(candidates[entry - 1]);
795
+ return set;
440
796
  };
441
797
 
442
- // TLC's TableauLiveChecker#addNextState for a node it finds after it expanded the node's state.
443
798
  const expandLate = (
444
- behavior: BehaviorGraph,
799
+ behavior: BehaviorGraph<State>,
445
800
  tableau: Tableau,
446
- state: Value[],
801
+ state: State,
447
802
  index: number,
448
803
  node: number,
804
+ row: Int8Array,
805
+ offset: number,
449
806
  ) => {
450
- const stateResults = checkState(behavior, index, state);
807
+ const stateResults = checkState(behavior, index, state, row, offset);
451
808
  const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
452
- const actions: Uint8Array[] = [];
809
+ const actionCount = behavior.checks.actions.length;
810
+ const actions: number[] = [];
453
811
  const successors: number[] = [];
454
- const selfActions =
455
- tableauNode.successors.length > 0
456
- ? checkAction(behavior, index, state, state)
457
- : new Uint8Array(0);
812
+ const selfResults = new Uint8Array(actionCount);
813
+ if (tableauNode.successors.length > 0) {
814
+ checkAction(behavior, index, state, row, offset, state, createEdgeRows(1), 0, selfResults, 0);
815
+ }
458
816
  for (const next of tableauNode.successors) {
459
- if (!isConsistent(tableau, next, index, state)) continue;
817
+ if (!isConsistent(behavior, next, index, state, row, offset)) continue;
460
818
  if (
461
819
  isAccepting(tableau, next) &&
462
820
  behavior.errorNode === undefined &&
463
- hasEmptyModel(behavior)
821
+ behavior.solution.models.some(isEmptyModel)
464
822
  ) {
465
823
  behavior.errorNode = node;
466
824
  return;
@@ -469,90 +827,140 @@ export const createLivenessChecker = (
469
827
  if (existing !== undefined && successors.includes(existing)) continue;
470
828
  const target = existing ?? recordNode(behavior, index, next);
471
829
  successors.push(target);
472
- actions.push(selfActions);
473
- if (existing === undefined) expandLate(behavior, tableau, state, index, target);
830
+ actions.push(0);
831
+ if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
474
832
  }
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;
478
- for (const next of tableauNode.successors) {
479
- 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.
482
- if (successor.index === -1) continue;
483
- const existing = getNodeId(behavior, successor.index, next);
484
- if (existing !== undefined && successors.includes(existing)) continue;
485
- const target = existing ?? recordNode(behavior, successor.index, next);
486
- successors.push(target);
487
- actions.push(successorActions);
488
- if (existing === undefined && isDone) {
489
- expandLate(behavior, tableau, successor.state, successor.index, target);
833
+ // The results of the step to the state itself come first, then those of each successor.
834
+ const actionBatches = [selfResults];
835
+ let stepCount = 1;
836
+ search.forEachActionSuccessors(index, state, (nextStates) => {
837
+ const edges = createEdgeRows(nextStates.length);
838
+ const results = new Uint8Array(nextStates.length * actionCount);
839
+ actionBatches.push(results);
840
+ for (let position = 0; position < nextStates.length; position++) {
841
+ const successor = nextStates[position];
842
+ const successorRow = createRows(1);
843
+ checkAction(
844
+ behavior,
845
+ index,
846
+ state,
847
+ row,
848
+ offset,
849
+ successor.state,
850
+ edges,
851
+ position * actionIds.size,
852
+ results,
853
+ position * actionCount,
854
+ );
855
+ const isDone = behavior.isDone[successor.index] === true;
856
+ for (const next of tableauNode.successors) {
857
+ if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
858
+ const existing = getNodeId(behavior, successor.index, next);
859
+ if (existing !== undefined && successors.includes(existing)) continue;
860
+ const target = existing ?? recordNode(behavior, successor.index, next);
861
+ successors.push(target);
862
+ actions.push(stepCount + position);
863
+ if (existing === undefined && isDone) {
864
+ expandLate(
865
+ behavior,
866
+ tableau,
867
+ successor.state,
868
+ successor.index,
869
+ target,
870
+ successorRow,
871
+ 0,
872
+ );
873
+ }
490
874
  }
491
875
  }
876
+ stepCount += nextStates.length;
877
+ });
878
+ if (successors.length > 0) {
879
+ const actionResults = new Uint8Array(stepCount * actionCount);
880
+ for (let batch = 0, resultOffset = 0; batch < actionBatches.length; batch++) {
881
+ actionResults.set(actionBatches[batch], resultOffset);
882
+ resultOffset += actionBatches[batch].length;
883
+ }
884
+ writeNode(behavior, node, successors, actionResults, actions, stateResults);
492
885
  }
493
- if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
494
886
  };
495
887
 
496
888
  const addTableauState = (
497
- behavior: BehaviorGraph,
889
+ behavior: BehaviorGraph<State>,
498
890
  tableau: Tableau,
499
- set: LiveSuccessor[],
500
- actionResults: Uint8Array[],
891
+ set: LiveSuccessor<State>[],
892
+ rows: Int8Array,
893
+ actionResults: Uint8Array,
501
894
  stateResults: Uint8Array,
502
895
  index: number,
503
896
  ) => {
504
- const consistency = tableau.nodes.map((_, node) =>
505
- set.map((successor) => isConsistent(tableau, node, index, successor.state)),
506
- );
897
+ const atomCount = stateAtoms.size;
898
+ // Whether each successor is consistent with each tableau node, node by node.
899
+ const consistency = new Uint8Array(tableau.nodes.length * set.length);
900
+ evaluateFrom(index, () => {
901
+ for (let node = 0; node < tableau.nodes.length; node++) {
902
+ for (let position = 0; position < set.length; position++) {
903
+ if (holdsNode(behavior, node, set[position].state, rows, position * atomCount)) {
904
+ consistency[node * set.length + position] = 1;
905
+ }
906
+ }
907
+ }
908
+ });
909
+ if (!hasState(behavior, index)) behavior.stateCount++;
507
910
  behavior.isDone[index] = true;
508
911
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
509
912
  for (const node of getStateNodes(behavior, index)) {
510
913
  const successors: number[] = [];
511
- const actions: Uint8Array[] = [];
914
+ const actions: number[] = [];
512
915
  set.forEach((successor, position) => {
513
916
  const isDone = behavior.isDone[successor.index] === true;
514
917
  for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
515
- if (!consistency[next][position]) continue;
918
+ if (consistency[next * set.length + position] === 0) continue;
516
919
  const existing = getNodeId(behavior, successor.index, next);
517
920
  if (existing !== undefined && successors.includes(existing)) continue;
518
921
  const target = existing ?? recordNode(behavior, successor.index, next);
519
922
  successors.push(target);
520
- actions.push(actionResults[position]);
923
+ actions.push(position);
521
924
  if (existing === undefined && isDone) {
522
- expandLate(behavior, tableau, successor.state, successor.index, target);
925
+ expandLate(
926
+ behavior,
927
+ tableau,
928
+ successor.state,
929
+ successor.index,
930
+ target,
931
+ rows,
932
+ position * atomCount,
933
+ );
523
934
  }
524
935
  }
525
936
  });
526
- writeNode(behavior, node, successors, actions, stateResults);
937
+ writeNode(behavior, node, successors, actionResults, actions, stateResults);
527
938
  }
528
- if (behavior.errorNode === undefined) return undefined;
529
- return removeRepeats(
530
- getPath(behavior, behavior.errorNode)
531
- .reverse()
532
- .map((node) => behavior.nodeStates[node]),
533
- );
939
+ return behavior.errorNode === undefined
940
+ ? undefined
941
+ : getStatePath(behavior, behavior.errorNode);
534
942
  };
535
943
 
536
944
  const addPlainState = (
537
- behavior: BehaviorGraph,
538
- set: LiveSuccessor[],
539
- actionResults: Uint8Array[],
945
+ behavior: BehaviorGraph<State>,
946
+ set: LiveSuccessor<State>[],
947
+ actionResults: Uint8Array,
540
948
  stateResults: Uint8Array,
541
949
  index: number,
542
950
  ) => {
543
951
  while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
544
952
  const successors: number[] = [];
545
- const actions: Uint8Array[] = [];
953
+ const actions: number[] = [];
546
954
  set.forEach((successor, position) => {
547
955
  if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
548
956
  successors.push(successor.index);
549
- actions.push(actionResults[position]);
957
+ actions.push(position);
550
958
  });
551
- writeNode(behavior, index, successors, actions, stateResults);
959
+ if (!isWritten(behavior, index)) behavior.stateCount++;
960
+ writeNode(behavior, index, successors, actionResults, actions, stateResults);
552
961
  };
553
962
 
554
- // The shortest path from an initial node to the node, last node first, as TLC's getPath finds it.
555
- const getPath = (behavior: BehaviorGraph, target: number) => {
963
+ const getPath = (behavior: BehaviorGraph<State>, target: number) => {
556
964
  if (behavior.initial.includes(target)) return [target];
557
965
  const parents = new Map<number, number>();
558
966
  const queue: number[] = [];
@@ -578,9 +986,15 @@ export const createLivenessChecker = (
578
986
  throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
579
987
  };
580
988
 
581
- // TLC's LiveWorker#checkSccs, a Tarjan search that pushes every successor of a node at once.
989
+ const getStatePath = (behavior: BehaviorGraph<State>, target: number) =>
990
+ removeRepeats(
991
+ getPath(behavior, target)
992
+ .reverse()
993
+ .map((node) => behavior.nodeStates[node]),
994
+ );
995
+
582
996
  const findLassoInModel = (
583
- behavior: BehaviorGraph,
997
+ behavior: BehaviorGraph<State>,
584
998
  model: Solution["models"][number],
585
999
  ): Lasso | undefined => {
586
1000
  const solution = behavior.solution;
@@ -635,91 +1049,85 @@ export const createLivenessChecker = (
635
1049
  return getLasso(root, members, membersByState);
636
1050
  };
637
1051
 
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
1052
  const getLasso = (
641
1053
  root: number,
642
1054
  members: Set<number>,
643
1055
  membersByState: Map<number, number[]>,
644
1056
  ) => {
645
- const prefix = removeRepeats(
646
- getPath(behavior, root)
647
- .reverse()
648
- .map((node) => behavior.nodeStates[node]),
649
- );
1057
+ const prefix = getStatePath(behavior, root);
650
1058
  const cycleStack: number[] = [];
651
1059
  const seen = new Set<number>([root]);
652
1060
  const stateDone = model.infinitelyOftenStates.map(() => false);
653
1061
  const actionDone = model.infinitelyOftenActions.map(() => false);
654
1062
  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);
1063
+ let remainingCount = stateDone.length + actionDone.length + promiseDone.length;
1064
+ let currentNode = root;
658
1065
  const moveTo = (next: number) => {
659
- cycleStack.push(current.node);
660
- current.node = next;
1066
+ cycleStack.push(currentNode);
1067
+ currentNode = next;
661
1068
  };
662
- while (remaining.count > 0) {
663
- const countAtStart = remaining.count;
1069
+ while (remainingCount > 0) {
1070
+ const countAtStart = remainingCount;
664
1071
  while (true) {
665
1072
  model.infinitelyOftenStates.forEach((position, slot) => {
666
- if (!stateDone[slot] && getStateResult(behavior, current.node, position)) {
1073
+ if (!stateDone[slot] && getStateResult(behavior, currentNode, position)) {
667
1074
  stateDone[slot] = true;
668
- remaining.count--;
1075
+ remainingCount--;
669
1076
  }
670
1077
  });
671
1078
  solution.promises.forEach((promise, position) => {
672
- if (!promiseDone[position] && isFulfilled(current.node, promise)) {
1079
+ if (!promiseDone[position] && isFulfilled(currentNode, promise)) {
673
1080
  promiseDone[position] = true;
674
- remaining.count--;
1081
+ remainingCount--;
675
1082
  }
676
1083
  });
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) => {
1084
+ if (remainingCount <= 0) break;
1085
+ let lastNext = -1;
1086
+ let unvisitedNext = -1;
1087
+ const countBeforeActions = remainingCount;
1088
+ const isTaken = getNodeSuccessors(behavior, currentNode).some((next, edge) => {
681
1089
  if (membersByState.has(behavior.nodeStates[next])) {
682
- if (!isMember(next) || !isAllowed(current.node, edge)) return false;
683
- step.last = next;
1090
+ if (!members.has(next) || !isAllowed(currentNode, edge)) return false;
1091
+ lastNext = next;
684
1092
  model.infinitelyOftenActions.forEach((position, slot) => {
685
- if (!actionDone[slot] && getAction(current.node, edge, position)) {
1093
+ if (!actionDone[slot] && getAction(currentNode, edge, position)) {
686
1094
  actionDone[slot] = true;
687
- remaining.count--;
1095
+ remainingCount--;
688
1096
  }
689
1097
  });
690
1098
  }
691
- if (remaining.count < countBeforeActions) {
1099
+ if (remainingCount < countBeforeActions) {
692
1100
  moveTo(next);
693
1101
  seen.clear();
694
1102
  return true;
695
1103
  }
696
- if (isMember(next) && !seen.has(next)) step.unvisited = next;
1104
+ if (members.has(next) && !seen.has(next)) unvisitedNext = next;
697
1105
  return false;
698
1106
  });
699
- if (taken) break;
700
- if (remaining.count < countAtStart) {
701
- moveTo(step.last);
1107
+ if (isTaken) break;
1108
+ if (remainingCount < countAtStart) {
1109
+ moveTo(lastNext);
702
1110
  seen.clear();
703
1111
  break;
704
1112
  }
705
- while (step.unvisited === -1) {
1113
+ while (unvisitedNext === -1) {
706
1114
  const previous = cycleStack.pop();
707
1115
  if (previous === undefined) {
708
1116
  throw new TlaEvaluationError(
709
1117
  "TLC failed to build the counterexample of a liveness property",
710
1118
  );
711
1119
  }
712
- current.node = previous;
713
- step.unvisited =
1120
+ currentNode = previous;
1121
+ unvisitedNext =
714
1122
  getNodeSuccessors(behavior, previous).find(
715
- (next) => isMember(next) && !seen.has(next),
1123
+ (next) => members.has(next) && !seen.has(next),
716
1124
  ) ?? -1;
717
1125
  }
718
- moveTo(step.unvisited);
719
- seen.add(step.unvisited);
1126
+ moveTo(unvisitedNext);
1127
+ seen.add(unvisitedNext);
720
1128
  }
721
1129
  }
722
- const postfix = getClosingPath(root, current.node, membersByState, isAllowed);
1130
+ const postfix = getClosingPath(root, currentNode, membersByState);
723
1131
  for (let position = cycleStack.length - 1; position >= 0; position--) {
724
1132
  const state = behavior.nodeStates[cycleStack[position]];
725
1133
  if (postfix[postfix.length - 1] !== state) postfix.push(state);
@@ -733,13 +1141,7 @@ export const createLivenessChecker = (
733
1141
  };
734
1142
  };
735
1143
 
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
- ) => {
1144
+ const getClosingPath = (root: number, end: number, membersByState: Map<number, number[]>) => {
743
1145
  if (end === root) return [];
744
1146
  const start = behavior.nodeStates[end];
745
1147
  const parents = new Map<number, number>();
@@ -748,7 +1150,7 @@ export const createLivenessChecker = (
748
1150
  for (let state = start, parent = -1, position = 0; ; position++) {
749
1151
  for (const node of membersByState.get(state) ?? []) {
750
1152
  for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
751
- if (next === node || !isAllowedEdge(node, edge)) continue;
1153
+ if (next === node || !isAllowed(node, edge)) continue;
752
1154
  if (next === root) {
753
1155
  const path: number[] = [];
754
1156
  for (let item = state, itemParent = parent; item !== start;) {
@@ -779,7 +1181,7 @@ export const createLivenessChecker = (
779
1181
 
780
1182
  for (let position = 0; position < queue.length; position++) {
781
1183
  const stack = [queue[position], UNVISITED, 0];
782
- const counter = { link: 0 };
1184
+ let nextLink = 0;
783
1185
  while (stack.length >= 3) {
784
1186
  const lowLink = stack.pop() ?? 0;
785
1187
  const location = stack.pop();
@@ -796,10 +1198,10 @@ export const createLivenessChecker = (
796
1198
  stack.push(Math.min(lowLink, links[node]));
797
1199
  continue;
798
1200
  }
799
- links[node] = counter.link;
1201
+ links[node] = nextLink;
800
1202
  stack.push(lowLink, node, SCC_MARKER);
801
1203
  components.push(node);
802
- const nextLowLink = { value: counter.link++ };
1204
+ let nextLowLink = nextLink++;
803
1205
  getNodeSuccessors(behavior, node).forEach((next, edge) => {
804
1206
  if (!isWritten(behavior, next)) return;
805
1207
  if (!isAllowed(node, edge)) {
@@ -807,9 +1209,9 @@ export const createLivenessChecker = (
807
1209
  return;
808
1210
  }
809
1211
  if (links[next] === UNVISITED) stack.push(next, UNVISITED);
810
- else nextLowLink.value = Math.min(nextLowLink.value, links[next]);
1212
+ else nextLowLink = Math.min(nextLowLink, links[next]);
811
1213
  });
812
- stack.push(nextLowLink.value);
1214
+ stack.push(nextLowLink);
813
1215
  }
814
1216
  }
815
1217
  return undefined;
@@ -817,59 +1219,89 @@ export const createLivenessChecker = (
817
1219
 
818
1220
  return {
819
1221
  branches: behaviors.length,
820
- addInitialState: (index, state, tracing) => {
821
- evaluation.environment = tracing ?? environment;
822
- shared.states.clear();
823
- shared.actions.clear();
824
- try {
825
- for (const behavior of behaviors) {
826
- const tableau = behavior.solution.tableau;
827
- if (!tableau) {
828
- behavior.initial.push(index);
829
- continue;
830
- }
831
- for (let node = 0; node < tableau.initialCount; node++) {
832
- if (!isConsistent(tableau, node, undefined, state)) continue;
833
- behavior.initial.push(
834
- getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
835
- );
836
- }
1222
+ addInitialState: (index, state) => {
1223
+ const row = createRows(1);
1224
+ for (const behavior of behaviors) {
1225
+ const tableau = behavior.solution.tableau;
1226
+ if (!tableau) {
1227
+ behavior.initial.push(index);
1228
+ continue;
1229
+ }
1230
+ for (let node = 0; node < tableau.initialCount; node++) {
1231
+ if (!isConsistent(behavior, node, undefined, state, row, 0)) continue;
1232
+ behavior.initial.push(
1233
+ getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
1234
+ );
837
1235
  }
838
- } finally {
839
- evaluation.environment = environment;
840
1236
  }
841
1237
  },
842
- addState: (index, state, successors, tracing) => {
843
- evaluation.environment = tracing ?? environment;
844
- shared.states.clear();
845
- shared.actions.clear();
846
- try {
847
- const set = getSuccessorSet(index, state, successors);
848
- for (const behavior of behaviors) {
849
- const actionResults = set.map((successor) =>
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(
1238
+ addState: (index, state, successors, isRerun) => {
1239
+ const set = getSuccessorSet(index, state, successors);
1240
+ const rows = createRows(set.length);
1241
+ // The set holds the state itself, as a successor of the same index.
1242
+ const offset = set.findIndex((successor) => successor.index === index) * stateAtoms.size;
1243
+ const edges = createEdgeRows(set.length);
1244
+ for (const behavior of behaviors) {
1245
+ const actionCount = behavior.checks.actions.length;
1246
+ const actionResults = new Uint8Array(set.length * actionCount);
1247
+ set.forEach((successor, position) =>
1248
+ checkAction(
859
1249
  behavior,
860
- tableau,
861
- set,
862
- actionResults,
863
- stateResults,
864
1250
  index,
865
- );
866
- if (accepted) return accepted;
1251
+ state,
1252
+ rows,
1253
+ offset,
1254
+ successor.state,
1255
+ edges,
1256
+ position * actionIds.size,
1257
+ actionResults,
1258
+ position * actionCount,
1259
+ ),
1260
+ );
1261
+ const stateResults = checkState(behavior, index, state, rows, offset);
1262
+ const tableau = behavior.solution.tableau;
1263
+ // TLC's rerun for a call stack fails an assertion, without a call stack, on a branch that has every edge of the state.
1264
+ if (
1265
+ isRerun &&
1266
+ (tableau
1267
+ ? getStateNodes(behavior, index).some((node) => behavior.edgeCounts[node] > 0)
1268
+ : set.every((successor) => isWritten(behavior, successor.index)))
1269
+ ) {
1270
+ throw new TlaEvaluationError("The behavior graph holds every edge of the state already.");
867
1271
  }
868
- return undefined;
869
- } finally {
870
- evaluation.environment = environment;
1272
+ if (!tableau) {
1273
+ addPlainState(behavior, set, actionResults, stateResults, index);
1274
+ continue;
1275
+ }
1276
+ const accepted = addTableauState(
1277
+ behavior,
1278
+ tableau,
1279
+ set,
1280
+ rows,
1281
+ actionResults,
1282
+ stateResults,
1283
+ index,
1284
+ );
1285
+ if (accepted) return accepted;
871
1286
  }
1287
+ return undefined;
872
1288
  },
1289
+ storeState: (pending, index) => {
1290
+ for (const behavior of behaviors) {
1291
+ const tableau = behavior.solution.tableau;
1292
+ if (!tableau) continue;
1293
+ const nodes: number[] = [];
1294
+ for (let tableauNode = 0; tableauNode < tableau.nodes.length; tableauNode++) {
1295
+ const node = getNodeId(behavior, pending, tableauNode);
1296
+ if (node !== undefined) nodes.push(node);
1297
+ }
1298
+ for (const node of nodes.sort((left, right) => left - right)) {
1299
+ behavior.nodeStates[node] = index;
1300
+ linkNode(behavior, index, behavior.nodeTableaux[node], node);
1301
+ }
1302
+ }
1303
+ },
1304
+ getStateCounts: () => behaviors.map((behavior) => behavior.stateCount),
873
1305
  findViolation: () => {
874
1306
  for (const behavior of behaviors) {
875
1307
  for (const model of behavior.solution.models) {
@@ -879,16 +1311,5 @@ export const createLivenessChecker = (
879
1311
  }
880
1312
  return undefined;
881
1313
  },
882
- // TLC names every property that the counterexample violates, once each.
883
- getViolatedProperties: (path, cycleStart) => [
884
- ...new Set(
885
- properties
886
- .filter(
887
- (_, position) =>
888
- !evaluateOnLasso(negations[position].body, path, cycleStart, 0, environment),
889
- )
890
- .map((property) => property.name),
891
- ),
892
- ],
893
1314
  };
894
1315
  };