tla-ts 0.0.9-dev.8298a52 → 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 +8 -0
  2. package/dist/compile.cjs +6 -6
  3. package/dist/compile.js +10 -10
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +57 -53
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +121 -12
  8. package/dist/index.d.ts +121 -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 +1 -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 +1155 -900
  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 +318 -656
  41. package/src/cli/typescript.ts +0 -3
  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 +260 -371
  51. package/src/errors.ts +93 -58
  52. package/src/evaluate.ts +848 -374
  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 +97 -43
  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 -325
  64. package/src/liveness.ts +224 -131
  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 +34 -57
  88. package/src/parallel.ts +62 -72
  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 +129 -38
  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 +296 -105
  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 +10 -25
  612. package/src/typescript/collections.ts +34 -35
  613. package/src/typescript/compile.ts +1 -8
  614. package/src/typescript/context.ts +0 -12
  615. package/src/typescript/emit.ts +0 -1
  616. package/src/typescript/expressions.ts +0 -12
  617. package/src/typescript/formula.ts +9 -15
  618. package/src/typescript/functions.ts +6 -17
  619. package/src/typescript/model.ts +14 -16
  620. package/src/typescript/names.ts +0 -2
  621. package/src/typescript/program.ts +0 -3
  622. package/src/typescript/properties.ts +6 -8
  623. package/src/typescript/scope.ts +0 -5
  624. package/src/typescript/steps.ts +20 -28
  625. package/src/typescript/types.ts +3 -10
  626. package/src/values.ts +917 -522
  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
+ );
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));
230
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,93 +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
- // A check that fails leaves no source, so the failure's trace reads the levels of the search.
272
- const evaluateFrom = <Result>(source: number | undefined, evaluate: () => Result) => {
273
- environment.runtime.setLivenessSource(source);
274
- try {
275
- return evaluate();
276
- } finally {
277
- environment.runtime.setLivenessSource(undefined);
278
- }
279
- };
280
- const evaluateState = (predicate: LiveExpression, state: Value[]) =>
281
- evaluateLive(
282
- predicate,
283
- state,
284
- undefined,
285
- evaluation.environment,
286
- isShared ? getStateCache(state) : new Map(),
287
- );
288
- const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
289
- evaluateFrom(source, () =>
290
- Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
291
- evaluateState(predicate, state) ? 1 : 0,
292
- ),
293
- );
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.
294
610
  const checkAction = (
295
- behavior: BehaviorGraph,
611
+ behavior: BehaviorGraph<State>,
296
612
  source: number,
297
- state: Value[],
298
- 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,
299
621
  ) =>
300
622
  evaluateFrom(source, () => {
301
- const predicates = behavior.solution.actionChecks;
302
- if (!isShared) {
303
- return Uint8Array.from(predicates, (predicate) =>
304
- evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
305
- );
306
- }
307
- const stateCache = getStateCache(state);
308
- const results = shared.actions.get(state) ?? new Map<Value[], Int8Array>();
309
- shared.actions.set(state, results);
310
- const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
311
- results.set(successor, known);
312
- return Uint8Array.from(behavior.actionIds, (id, position) => {
313
- if (known[id] === -1) {
314
- known[id] = evaluateLive(
315
- 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],
316
628
  state,
629
+ row,
630
+ offset,
317
631
  successor,
318
- evaluation.environment,
319
- stateCache,
320
632
  )
321
633
  ? 1
322
634
  : 0;
635
+ continue;
323
636
  }
324
- return known[id];
325
- });
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
+ }
326
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
+ };
327
662
  const isConsistent = (
328
- tableau: Tableau,
663
+ behavior: BehaviorGraph<State>,
329
664
  node: number,
330
665
  source: number | undefined,
331
- state: Value[],
332
- ) =>
333
- evaluateFrom(source, () =>
334
- tableau.nodes[node].statePredicates.every((predicate) => evaluateState(predicate, state)),
335
- );
336
- // TLC 1.7.4 doesn't stop at a tableau node that accepts every behavior, so it finds a violation
337
- // 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
+
338
671
  const isAccepting = (tableau: Tableau, node: number) => {
339
- if (environment.runtime.version === "1.7.4") return false;
672
+ if (!isAcceptingFound) return false;
340
673
  const tableauNode = tableau.nodes[node];
341
674
  return (
342
675
  tableauNode.particle.length === 0 &&
@@ -344,22 +677,19 @@ export const createLivenessChecker = (
344
677
  tableauNode.successors[0] === node
345
678
  );
346
679
  };
347
- const hasEmptyModel = (behavior: BehaviorGraph) =>
348
- behavior.solution.models.some(
349
- (model) =>
350
- model.eventuallyAlways.length === 0 &&
351
- model.infinitelyOftenStates.length === 0 &&
352
- model.infinitelyOftenActions.length === 0,
353
- );
354
680
 
355
- const getNodeId = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
681
+ const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
356
682
  if (!behavior.solution.tableau) return state;
357
683
  const slots = behavior.nodeIds.slots;
358
684
  const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
359
685
  return slots[slot] === 0 ? undefined : slots[slot + 2];
360
686
  };
361
- const recordNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
362
- const node = pushNode(behavior, state, tableauNode);
687
+ const linkNode = (
688
+ behavior: BehaviorGraph<State>,
689
+ state: number,
690
+ tableauNode: number,
691
+ node: number,
692
+ ) => {
363
693
  const table = behavior.nodeIds;
364
694
  if (++table.size * 2 > table.slots.length / 3) {
365
695
  const old = table.slots;
@@ -375,24 +705,43 @@ export const createLivenessChecker = (
375
705
  }
376
706
  }
377
707
  table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
708
+ if (state < 0) return node;
378
709
  const last = behavior.lastNodes.data[state] ?? NO_NODE;
379
710
  if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
380
711
  else behavior.nextSiblings[last] = node;
381
712
  writeToPool(behavior.lastNodes, state, [node]);
382
713
  return node;
383
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.
384
726
  const writeNode = (
385
- behavior: BehaviorGraph,
727
+ behavior: BehaviorGraph<State>,
386
728
  node: number,
387
729
  targets: number[],
388
- actions: Uint8Array[],
730
+ actionResults: Uint8Array,
731
+ actions: number[],
389
732
  stateResults: Uint8Array,
390
733
  ) => {
391
734
  const start = behavior.edgeTargets.length;
392
735
  const actionCount = behavior.solution.actionChecks.length;
393
736
  writeToPool(behavior.edgeTargets, start, targets);
394
- actions.forEach((results, position) =>
395
- 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
+ ),
396
745
  );
397
746
  writeToPool(
398
747
  behavior.stateResults,
@@ -403,67 +752,73 @@ export const createLivenessChecker = (
403
752
  behavior.edgeCounts[node] = targets.length;
404
753
  };
405
754
 
406
- // TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
407
- // iterates in slot order. Its capacity starts at 16 times a factor that grows with every set
408
- // that outgrows it.
409
- const getSuccessorSet = (index: number, state: Value[], successors: LiveSuccessor[]) => {
410
- const table = {
411
- slots: Array.from<LiveSuccessor | undefined>({
412
- length: SUCCESSOR_CAPACITY * capacity.multiplier,
413
- }),
414
- count: 0,
415
- };
416
- 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];
417
768
  for (
418
- let slot = (search.getFingerprint(successor) & 0x7fffffff) % slots.length;
769
+ let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
419
770
  ;
420
771
  slot = (slot + 1) % slots.length
421
772
  ) {
422
773
  const entry = slots[slot];
423
- if (entry === undefined) {
424
- slots[slot] = successor;
774
+ if (entry === 0) {
775
+ slots[slot] = position + 1;
425
776
  return true;
426
777
  }
427
- 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))
428
780
  return false;
429
781
  }
430
782
  };
431
- const addSuccessor = (successor: LiveSuccessor) => {
432
- if (table.count >= table.slots.length >> 1) {
433
- const old = table.slots;
434
- table.slots = Array.from<LiveSuccessor | undefined>({ length: 2 * old.length + 1 });
435
- 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);
436
789
  }
437
- if (insertSuccessor(table.slots, successor)) table.count++;
438
- };
439
- successors.forEach(addSuccessor);
440
- addSuccessor({ index, state });
441
- if (table.slots.length > SUCCESSOR_CAPACITY * capacity.multiplier) capacity.multiplier++;
442
- 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;
443
796
  };
444
797
 
445
- // TLC's TableauLiveChecker#addNextState for a node it finds after it expanded the node's state.
446
798
  const expandLate = (
447
- behavior: BehaviorGraph,
799
+ behavior: BehaviorGraph<State>,
448
800
  tableau: Tableau,
449
- state: Value[],
801
+ state: State,
450
802
  index: number,
451
803
  node: number,
804
+ row: Int8Array,
805
+ offset: number,
452
806
  ) => {
453
- const stateResults = checkState(behavior, index, state);
807
+ const stateResults = checkState(behavior, index, state, row, offset);
454
808
  const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
455
- const actions: Uint8Array[] = [];
809
+ const actionCount = behavior.checks.actions.length;
810
+ const actions: number[] = [];
456
811
  const successors: number[] = [];
457
- const selfActions =
458
- tableauNode.successors.length > 0
459
- ? checkAction(behavior, index, state, state)
460
- : 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
+ }
461
816
  for (const next of tableauNode.successors) {
462
- if (!isConsistent(tableau, next, index, state)) continue;
817
+ if (!isConsistent(behavior, next, index, state, row, offset)) continue;
463
818
  if (
464
819
  isAccepting(tableau, next) &&
465
820
  behavior.errorNode === undefined &&
466
- hasEmptyModel(behavior)
821
+ behavior.solution.models.some(isEmptyModel)
467
822
  ) {
468
823
  behavior.errorNode = node;
469
824
  return;
@@ -472,90 +827,140 @@ export const createLivenessChecker = (
472
827
  if (existing !== undefined && successors.includes(existing)) continue;
473
828
  const target = existing ?? recordNode(behavior, index, next);
474
829
  successors.push(target);
475
- actions.push(selfActions);
476
- 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);
477
832
  }
478
- for (const successor of search.getSuccessors(index, state)) {
479
- const successorActions = checkAction(behavior, index, state, successor.state);
480
- const isDone = behavior.isDone[successor.index] === true;
481
- for (const next of tableauNode.successors) {
482
- if (!isConsistent(tableau, next, index, successor.state)) continue;
483
- // A successor the search never stored follows a violation or an error, after which nothing
484
- // checks the graph. TLC records its node, which it never expands.
485
- if (successor.index === -1) continue;
486
- const existing = getNodeId(behavior, successor.index, next);
487
- if (existing !== undefined && successors.includes(existing)) continue;
488
- const target = existing ?? recordNode(behavior, successor.index, next);
489
- successors.push(target);
490
- actions.push(successorActions);
491
- if (existing === undefined && isDone) {
492
- 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
+ }
493
874
  }
494
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);
495
885
  }
496
- if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
497
886
  };
498
887
 
499
888
  const addTableauState = (
500
- behavior: BehaviorGraph,
889
+ behavior: BehaviorGraph<State>,
501
890
  tableau: Tableau,
502
- set: LiveSuccessor[],
503
- actionResults: Uint8Array[],
891
+ set: LiveSuccessor<State>[],
892
+ rows: Int8Array,
893
+ actionResults: Uint8Array,
504
894
  stateResults: Uint8Array,
505
895
  index: number,
506
896
  ) => {
507
- const consistency = tableau.nodes.map((_, node) =>
508
- set.map((successor) => isConsistent(tableau, node, index, successor.state)),
509
- );
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++;
510
910
  behavior.isDone[index] = true;
511
911
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
512
912
  for (const node of getStateNodes(behavior, index)) {
513
913
  const successors: number[] = [];
514
- const actions: Uint8Array[] = [];
914
+ const actions: number[] = [];
515
915
  set.forEach((successor, position) => {
516
916
  const isDone = behavior.isDone[successor.index] === true;
517
917
  for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
518
- if (!consistency[next][position]) continue;
918
+ if (consistency[next * set.length + position] === 0) continue;
519
919
  const existing = getNodeId(behavior, successor.index, next);
520
920
  if (existing !== undefined && successors.includes(existing)) continue;
521
921
  const target = existing ?? recordNode(behavior, successor.index, next);
522
922
  successors.push(target);
523
- actions.push(actionResults[position]);
923
+ actions.push(position);
524
924
  if (existing === undefined && isDone) {
525
- 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
+ );
526
934
  }
527
935
  }
528
936
  });
529
- writeNode(behavior, node, successors, actions, stateResults);
937
+ writeNode(behavior, node, successors, actionResults, actions, stateResults);
530
938
  }
531
- if (behavior.errorNode === undefined) return undefined;
532
- return removeRepeats(
533
- getPath(behavior, behavior.errorNode)
534
- .reverse()
535
- .map((node) => behavior.nodeStates[node]),
536
- );
939
+ return behavior.errorNode === undefined
940
+ ? undefined
941
+ : getStatePath(behavior, behavior.errorNode);
537
942
  };
538
943
 
539
944
  const addPlainState = (
540
- behavior: BehaviorGraph,
541
- set: LiveSuccessor[],
542
- actionResults: Uint8Array[],
945
+ behavior: BehaviorGraph<State>,
946
+ set: LiveSuccessor<State>[],
947
+ actionResults: Uint8Array,
543
948
  stateResults: Uint8Array,
544
949
  index: number,
545
950
  ) => {
546
951
  while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
547
952
  const successors: number[] = [];
548
- const actions: Uint8Array[] = [];
953
+ const actions: number[] = [];
549
954
  set.forEach((successor, position) => {
550
955
  if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
551
956
  successors.push(successor.index);
552
- actions.push(actionResults[position]);
957
+ actions.push(position);
553
958
  });
554
- writeNode(behavior, index, successors, actions, stateResults);
959
+ if (!isWritten(behavior, index)) behavior.stateCount++;
960
+ writeNode(behavior, index, successors, actionResults, actions, stateResults);
555
961
  };
556
962
 
557
- // The shortest path from an initial node to the node, last node first, as TLC's getPath finds it.
558
- const getPath = (behavior: BehaviorGraph, target: number) => {
963
+ const getPath = (behavior: BehaviorGraph<State>, target: number) => {
559
964
  if (behavior.initial.includes(target)) return [target];
560
965
  const parents = new Map<number, number>();
561
966
  const queue: number[] = [];
@@ -581,9 +986,15 @@ export const createLivenessChecker = (
581
986
  throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
582
987
  };
583
988
 
584
- // 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
+
585
996
  const findLassoInModel = (
586
- behavior: BehaviorGraph,
997
+ behavior: BehaviorGraph<State>,
587
998
  model: Solution["models"][number],
588
999
  ): Lasso | undefined => {
589
1000
  const solution = behavior.solution;
@@ -638,91 +1049,85 @@ export const createLivenessChecker = (
638
1049
  return getLasso(root, members, membersByState);
639
1050
  };
640
1051
 
641
- // TLC's LiveWorker#printTrace: a prefix to the root, a greedy walk through the component
642
- // until it satisfies every check, and a breadth-first path back to the root.
643
1052
  const getLasso = (
644
1053
  root: number,
645
1054
  members: Set<number>,
646
1055
  membersByState: Map<number, number[]>,
647
1056
  ) => {
648
- const prefix = removeRepeats(
649
- getPath(behavior, root)
650
- .reverse()
651
- .map((node) => behavior.nodeStates[node]),
652
- );
1057
+ const prefix = getStatePath(behavior, root);
653
1058
  const cycleStack: number[] = [];
654
1059
  const seen = new Set<number>([root]);
655
1060
  const stateDone = model.infinitelyOftenStates.map(() => false);
656
1061
  const actionDone = model.infinitelyOftenActions.map(() => false);
657
1062
  const promiseDone = solution.promises.map(() => false);
658
- const remaining = { count: stateDone.length + actionDone.length + promiseDone.length };
659
- const current = { node: root };
660
- const isMember = (node: number) => members.has(node);
1063
+ let remainingCount = stateDone.length + actionDone.length + promiseDone.length;
1064
+ let currentNode = root;
661
1065
  const moveTo = (next: number) => {
662
- cycleStack.push(current.node);
663
- current.node = next;
1066
+ cycleStack.push(currentNode);
1067
+ currentNode = next;
664
1068
  };
665
- while (remaining.count > 0) {
666
- const countAtStart = remaining.count;
1069
+ while (remainingCount > 0) {
1070
+ const countAtStart = remainingCount;
667
1071
  while (true) {
668
1072
  model.infinitelyOftenStates.forEach((position, slot) => {
669
- if (!stateDone[slot] && getStateResult(behavior, current.node, position)) {
1073
+ if (!stateDone[slot] && getStateResult(behavior, currentNode, position)) {
670
1074
  stateDone[slot] = true;
671
- remaining.count--;
1075
+ remainingCount--;
672
1076
  }
673
1077
  });
674
1078
  solution.promises.forEach((promise, position) => {
675
- if (!promiseDone[position] && isFulfilled(current.node, promise)) {
1079
+ if (!promiseDone[position] && isFulfilled(currentNode, promise)) {
676
1080
  promiseDone[position] = true;
677
- remaining.count--;
1081
+ remainingCount--;
678
1082
  }
679
1083
  });
680
- if (remaining.count <= 0) break;
681
- const step = { last: -1, unvisited: -1 };
682
- const countBeforeActions = remaining.count;
683
- 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) => {
684
1089
  if (membersByState.has(behavior.nodeStates[next])) {
685
- if (!isMember(next) || !isAllowed(current.node, edge)) return false;
686
- step.last = next;
1090
+ if (!members.has(next) || !isAllowed(currentNode, edge)) return false;
1091
+ lastNext = next;
687
1092
  model.infinitelyOftenActions.forEach((position, slot) => {
688
- if (!actionDone[slot] && getAction(current.node, edge, position)) {
1093
+ if (!actionDone[slot] && getAction(currentNode, edge, position)) {
689
1094
  actionDone[slot] = true;
690
- remaining.count--;
1095
+ remainingCount--;
691
1096
  }
692
1097
  });
693
1098
  }
694
- if (remaining.count < countBeforeActions) {
1099
+ if (remainingCount < countBeforeActions) {
695
1100
  moveTo(next);
696
1101
  seen.clear();
697
1102
  return true;
698
1103
  }
699
- if (isMember(next) && !seen.has(next)) step.unvisited = next;
1104
+ if (members.has(next) && !seen.has(next)) unvisitedNext = next;
700
1105
  return false;
701
1106
  });
702
- if (taken) break;
703
- if (remaining.count < countAtStart) {
704
- moveTo(step.last);
1107
+ if (isTaken) break;
1108
+ if (remainingCount < countAtStart) {
1109
+ moveTo(lastNext);
705
1110
  seen.clear();
706
1111
  break;
707
1112
  }
708
- while (step.unvisited === -1) {
1113
+ while (unvisitedNext === -1) {
709
1114
  const previous = cycleStack.pop();
710
1115
  if (previous === undefined) {
711
1116
  throw new TlaEvaluationError(
712
1117
  "TLC failed to build the counterexample of a liveness property",
713
1118
  );
714
1119
  }
715
- current.node = previous;
716
- step.unvisited =
1120
+ currentNode = previous;
1121
+ unvisitedNext =
717
1122
  getNodeSuccessors(behavior, previous).find(
718
- (next) => isMember(next) && !seen.has(next),
1123
+ (next) => members.has(next) && !seen.has(next),
719
1124
  ) ?? -1;
720
1125
  }
721
- moveTo(step.unvisited);
722
- seen.add(step.unvisited);
1126
+ moveTo(unvisitedNext);
1127
+ seen.add(unvisitedNext);
723
1128
  }
724
1129
  }
725
- const postfix = getClosingPath(root, current.node, membersByState, isAllowed);
1130
+ const postfix = getClosingPath(root, currentNode, membersByState);
726
1131
  for (let position = cycleStack.length - 1; position >= 0; position--) {
727
1132
  const state = behavior.nodeStates[cycleStack[position]];
728
1133
  if (postfix[postfix.length - 1] !== state) postfix.push(state);
@@ -736,13 +1141,7 @@ export const createLivenessChecker = (
736
1141
  };
737
1142
  };
738
1143
 
739
- // TLC's LiveWorker#bfsPostFix, the states from the walk's end back to the root, last first.
740
- const getClosingPath = (
741
- root: number,
742
- end: number,
743
- membersByState: Map<number, number[]>,
744
- isAllowedEdge: (node: number, edge: number) => boolean,
745
- ) => {
1144
+ const getClosingPath = (root: number, end: number, membersByState: Map<number, number[]>) => {
746
1145
  if (end === root) return [];
747
1146
  const start = behavior.nodeStates[end];
748
1147
  const parents = new Map<number, number>();
@@ -751,7 +1150,7 @@ export const createLivenessChecker = (
751
1150
  for (let state = start, parent = -1, position = 0; ; position++) {
752
1151
  for (const node of membersByState.get(state) ?? []) {
753
1152
  for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
754
- if (next === node || !isAllowedEdge(node, edge)) continue;
1153
+ if (next === node || !isAllowed(node, edge)) continue;
755
1154
  if (next === root) {
756
1155
  const path: number[] = [];
757
1156
  for (let item = state, itemParent = parent; item !== start;) {
@@ -782,7 +1181,7 @@ export const createLivenessChecker = (
782
1181
 
783
1182
  for (let position = 0; position < queue.length; position++) {
784
1183
  const stack = [queue[position], UNVISITED, 0];
785
- const counter = { link: 0 };
1184
+ let nextLink = 0;
786
1185
  while (stack.length >= 3) {
787
1186
  const lowLink = stack.pop() ?? 0;
788
1187
  const location = stack.pop();
@@ -799,10 +1198,10 @@ export const createLivenessChecker = (
799
1198
  stack.push(Math.min(lowLink, links[node]));
800
1199
  continue;
801
1200
  }
802
- links[node] = counter.link;
1201
+ links[node] = nextLink;
803
1202
  stack.push(lowLink, node, SCC_MARKER);
804
1203
  components.push(node);
805
- const nextLowLink = { value: counter.link++ };
1204
+ let nextLowLink = nextLink++;
806
1205
  getNodeSuccessors(behavior, node).forEach((next, edge) => {
807
1206
  if (!isWritten(behavior, next)) return;
808
1207
  if (!isAllowed(node, edge)) {
@@ -810,9 +1209,9 @@ export const createLivenessChecker = (
810
1209
  return;
811
1210
  }
812
1211
  if (links[next] === UNVISITED) stack.push(next, UNVISITED);
813
- else nextLowLink.value = Math.min(nextLowLink.value, links[next]);
1212
+ else nextLowLink = Math.min(nextLowLink, links[next]);
814
1213
  });
815
- stack.push(nextLowLink.value);
1214
+ stack.push(nextLowLink);
816
1215
  }
817
1216
  }
818
1217
  return undefined;
@@ -820,59 +1219,89 @@ export const createLivenessChecker = (
820
1219
 
821
1220
  return {
822
1221
  branches: behaviors.length,
823
- addInitialState: (index, state, tracing) => {
824
- evaluation.environment = tracing ?? environment;
825
- shared.states.clear();
826
- shared.actions.clear();
827
- try {
828
- for (const behavior of behaviors) {
829
- const tableau = behavior.solution.tableau;
830
- if (!tableau) {
831
- behavior.initial.push(index);
832
- continue;
833
- }
834
- for (let node = 0; node < tableau.initialCount; node++) {
835
- if (!isConsistent(tableau, node, undefined, state)) continue;
836
- behavior.initial.push(
837
- getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
838
- );
839
- }
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
+ );
840
1235
  }
841
- } finally {
842
- evaluation.environment = environment;
843
1236
  }
844
1237
  },
845
- addState: (index, state, successors, tracing) => {
846
- evaluation.environment = tracing ?? environment;
847
- shared.states.clear();
848
- shared.actions.clear();
849
- try {
850
- const set = getSuccessorSet(index, state, successors);
851
- for (const behavior of behaviors) {
852
- const actionResults = set.map((successor) =>
853
- checkAction(behavior, index, state, successor.state),
854
- );
855
- const stateResults = checkState(behavior, index, state);
856
- const tableau = behavior.solution.tableau;
857
- if (!tableau) {
858
- addPlainState(behavior, set, actionResults, stateResults, index);
859
- continue;
860
- }
861
- 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(
862
1249
  behavior,
863
- tableau,
864
- set,
865
- actionResults,
866
- stateResults,
867
1250
  index,
868
- );
869
- 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.");
870
1271
  }
871
- return undefined;
872
- } finally {
873
- 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;
874
1286
  }
1287
+ return undefined;
875
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),
876
1305
  findViolation: () => {
877
1306
  for (const behavior of behaviors) {
878
1307
  for (const model of behavior.solution.models) {
@@ -882,16 +1311,5 @@ export const createLivenessChecker = (
882
1311
  }
883
1312
  return undefined;
884
1313
  },
885
- // TLC names every property that the counterexample violates, once each.
886
- getViolatedProperties: (path, cycleStart) => [
887
- ...new Set(
888
- properties
889
- .filter(
890
- (_, position) =>
891
- !evaluateOnLasso(negations[position].body, path, cycleStart, 0, environment),
892
- )
893
- .map((property) => property.name),
894
- ),
895
- ],
896
1314
  };
897
1315
  };