tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.6b2a6741a

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 (551) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +3 -3
  3. package/dist/compile.js +1 -1
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +45 -41
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +5 -1
  8. package/dist/index.d.ts +5 -1
  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 +2682 -426
  15. package/dist/prove.js +2679 -423
  16. package/dist/run.cjs +43 -42
  17. package/dist/run.js +44 -43
  18. package/dist/tlapm.cjs +1 -1
  19. package/dist/tlapm.js +1 -1
  20. package/dist/transfer.cjs +43 -40
  21. package/dist/transfer.js +43 -40
  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 +4 -3
  26. package/src/bags.ts +46 -28
  27. package/src/check-trace.ts +2 -16
  28. package/src/check.ts +349 -91
  29. package/src/cli/runtime-invariants.ts +20 -56
  30. package/src/cli/tlapm.ts +424 -62
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +4 -5
  33. package/src/cli/tlc-usage.ts +0 -1
  34. package/src/cli/tlc.ts +26 -7
  35. package/src/cli/xml-exporter.ts +1 -1
  36. package/src/codegen.ts +9 -5
  37. package/src/dependencies.ts +72 -11
  38. package/src/dfid.ts +9 -2
  39. package/src/environment.ts +65 -36
  40. package/src/errors.ts +38 -3
  41. package/src/evaluate.ts +92 -32
  42. package/src/exit-codes.ts +5 -2
  43. package/src/instances.ts +5 -5
  44. package/src/java-overrides.ts +2 -2
  45. package/src/levels.ts +138 -90
  46. package/src/lexer.ts +5 -3
  47. package/src/liveness-checker.ts +572 -204
  48. package/src/liveness.ts +47 -32
  49. package/src/obligations/action.ts +10 -6
  50. package/src/obligations/anonymize.ts +33 -14
  51. package/src/obligations/enabled-axioms.ts +218 -0
  52. package/src/obligations/equality.ts +1 -3
  53. package/src/obligations/expression.ts +18 -6
  54. package/src/obligations/format.ts +0 -2
  55. package/src/obligations/generate.ts +22 -17
  56. package/src/obligations/index.ts +37 -7
  57. package/src/obligations/levels.ts +24 -11
  58. package/src/obligations/module.ts +1 -3
  59. package/src/obligations/normalize.ts +25 -17
  60. package/src/obligations/operators.ts +0 -2
  61. package/src/obligations/pragma.ts +53 -16
  62. package/src/obligations/printer.ts +48 -18
  63. package/src/obligations/proof.ts +3 -2
  64. package/src/obligations/regroup.ts +0 -2
  65. package/src/obligations/simplify.ts +17 -7
  66. package/src/obligations/source.ts +71 -17
  67. package/src/obligations/subexpression.ts +45 -18
  68. package/src/obligations/substitution.ts +1 -3
  69. package/src/obligations/temporal.ts +0 -2
  70. package/src/obligations/tuples.ts +0 -2
  71. package/src/parallel-worker.ts +8 -2
  72. package/src/parallel.ts +7 -2
  73. package/src/parser.ts +664 -287
  74. package/src/pretty-print.ts +1 -1
  75. package/src/prover/deciders.ts +11 -8
  76. package/src/prover/isabelle/decide.ts +3 -25
  77. package/src/prover/isabelle/encode.ts +71 -41
  78. package/src/prover/isabelle/isar/attrib.ts +250 -0
  79. package/src/prover/isabelle/isar/context.ts +335 -0
  80. package/src/prover/isabelle/isar/induct.ts +382 -0
  81. package/src/prover/isabelle/isar/inner-syntax.ts +149 -3
  82. package/src/prover/isabelle/isar/method.ts +506 -198
  83. package/src/prover/isabelle/isar/proof.ts +570 -14
  84. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  85. package/src/prover/isabelle/isar/theory.ts +479 -69
  86. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  87. package/src/prover/isabelle/isar/type-check.ts +83 -8
  88. package/src/prover/isabelle/provers/blast/blast.ts +0 -2
  89. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  90. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  91. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  92. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  93. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  94. package/src/prover/isabelle/provers/clasimp.ts +1 -3
  95. package/src/prover/isabelle/provers/classical.ts +45 -20
  96. package/src/prover/isabelle/provers/hypsubst.ts +2 -4
  97. package/src/prover/isabelle/pure/bicompose.ts +0 -2
  98. package/src/prover/isabelle/pure/consts.ts +0 -2
  99. package/src/prover/isabelle/pure/conv.ts +0 -2
  100. package/src/prover/isabelle/pure/drule.ts +63 -4
  101. package/src/prover/isabelle/pure/envir.ts +0 -2
  102. package/src/prover/isabelle/pure/goal.ts +1 -3
  103. package/src/prover/isabelle/pure/logic.ts +0 -2
  104. package/src/prover/isabelle/pure/name.ts +0 -2
  105. package/src/prover/isabelle/pure/net.ts +0 -2
  106. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  107. package/src/prover/isabelle/pure/pattern.ts +0 -2
  108. package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
  109. package/src/prover/isabelle/pure/rewriter.ts +4 -11
  110. package/src/prover/isabelle/pure/search.ts +0 -2
  111. package/src/prover/isabelle/pure/seq.ts +0 -2
  112. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  113. package/src/prover/isabelle/pure/table.ts +0 -2
  114. package/src/prover/isabelle/pure/tactic.ts +0 -2
  115. package/src/prover/isabelle/pure/tactical.ts +0 -2
  116. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  117. package/src/prover/isabelle/pure/term.ts +3 -5
  118. package/src/prover/isabelle/pure/thm.ts +0 -2
  119. package/src/prover/isabelle/pure/type.ts +0 -2
  120. package/src/prover/isabelle/pure/unify.ts +0 -2
  121. package/src/prover/isabelle/pure/variable.ts +0 -2
  122. package/src/prover/isabelle/tla/classical-setup.ts +1 -2
  123. package/src/prover/isabelle/tla/context.ts +51 -9
  124. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  125. package/src/prover/isabelle/tla/logic.ts +40 -1
  126. package/src/prover/isabelle/tla/simpdata.ts +0 -2
  127. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  128. package/src/prover/ocaml.ts +4 -1
  129. package/src/prover/prep/action.ts +19 -12
  130. package/src/prover/prep/enabled-axioms.ts +11 -2
  131. package/src/prover/prep/md5.ts +26 -29
  132. package/src/prover/prep/methods.ts +159 -50
  133. package/src/prover/prep/normalize.ts +38 -9
  134. package/src/prover/prove.ts +343 -65
  135. package/src/prover/ptl/decide.ts +95 -50
  136. package/src/prover/ptl/encode.ts +2 -3
  137. package/src/prover/ptl/tableau.ts +28 -2
  138. package/src/prover/smt/arithmetic.ts +310 -0
  139. package/src/prover/smt/axioms.ts +12 -8
  140. package/src/prover/smt/context.ts +42 -6
  141. package/src/prover/smt/data.ts +191 -84
  142. package/src/prover/smt/encode.ts +122 -43
  143. package/src/prover/smt/extensionality.ts +5 -3
  144. package/src/prover/smt/flatten.ts +4 -6
  145. package/src/prover/smt/format.ts +28 -4
  146. package/src/prover/smt/instances.ts +7 -1
  147. package/src/prover/smt/layout.ts +91 -0
  148. package/src/prover/smt/rewrite.ts +483 -116
  149. package/src/prover/smt/simplify.ts +441 -0
  150. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  151. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  152. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  153. package/src/prover/smt/solver/act-cache.ts +0 -1
  154. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  155. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  156. package/src/prover/smt/solver/aig.ts +889 -0
  157. package/src/prover/smt/solver/arith-rewriter.ts +613 -6
  158. package/src/prover/smt/solver/arith-terms.ts +121 -0
  159. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  160. package/src/prover/smt/solver/array-rewriter.ts +309 -0
  161. package/src/prover/smt/solver/asserted-formulas.ts +93 -15
  162. package/src/prover/smt/solver/ast-lt.ts +165 -11
  163. package/src/prover/smt/solver/ast-util.ts +160 -2
  164. package/src/prover/smt/solver/ast.ts +1449 -41
  165. package/src/prover/smt/solver/auf-solver.ts +0 -1
  166. package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
  167. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  168. package/src/prover/smt/solver/bound-manager.ts +196 -0
  169. package/src/prover/smt/solver/bound-simplifier.ts +600 -0
  170. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  171. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  172. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  173. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  174. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  175. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  176. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  177. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  178. package/src/prover/smt/solver/card2bv.ts +109 -0
  179. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  180. package/src/prover/smt/solver/cg-table.ts +39 -25
  181. package/src/prover/smt/solver/check-logic.ts +330 -0
  182. package/src/prover/smt/solver/clause.ts +0 -1
  183. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
  184. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  185. package/src/prover/smt/solver/context.ts +533 -114
  186. package/src/prover/smt/solver/ctx-simplify.ts +21 -12
  187. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  188. package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
  189. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  190. package/src/prover/smt/solver/demodulator.ts +786 -0
  191. package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
  192. package/src/prover/smt/solver/der.ts +38 -10
  193. package/src/prover/smt/solver/diff-neq.ts +205 -0
  194. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  195. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  196. package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
  197. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  198. package/src/prover/smt/solver/e-matching.ts +6 -7
  199. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  200. package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
  201. package/src/prover/smt/solver/enode.ts +100 -3
  202. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  203. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  204. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  205. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  206. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  207. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  208. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  209. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  210. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  211. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  212. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  213. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  214. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  215. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  216. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  217. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  218. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  219. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  220. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  221. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  222. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  223. package/src/prover/smt/solver/expr-ref.ts +0 -1
  224. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  225. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  226. package/src/prover/smt/solver/factor.ts +163 -0
  227. package/src/prover/smt/solver/fd-solver.ts +267 -0
  228. package/src/prover/smt/solver/fingerprints.ts +15 -15
  229. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  230. package/src/prover/smt/solver/flat-literals.ts +0 -1
  231. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  232. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  233. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  234. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  235. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  236. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  237. package/src/prover/smt/solver/goal.ts +177 -15
  238. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  239. package/src/prover/smt/solver/guard-set.ts +219 -0
  240. package/src/prover/smt/solver/hash.ts +0 -1
  241. package/src/prover/smt/solver/hashtable.ts +30 -16
  242. package/src/prover/smt/solver/inf-eps.ts +63 -0
  243. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  244. package/src/prover/smt/solver/internalizer.ts +109 -36
  245. package/src/prover/smt/solver/lackr.ts +381 -0
  246. package/src/prover/smt/solver/lbool.ts +0 -1
  247. package/src/prover/smt/solver/lia2card.ts +268 -0
  248. package/src/prover/smt/solver/lia2pb.ts +154 -0
  249. package/src/prover/smt/solver/literal.ts +0 -1
  250. package/src/prover/smt/solver/logic-tactics.ts +345 -0
  251. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  252. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  253. package/src/prover/smt/solver/lp/containers.ts +7 -2
  254. package/src/prover/smt/solver/lp/core-solver.ts +18 -3
  255. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  256. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  257. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  258. package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
  259. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  260. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  261. package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
  262. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  263. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  264. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  265. package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
  266. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  267. package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
  268. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  269. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  270. package/src/prover/smt/solver/lp/nex.ts +2 -2
  271. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  272. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  273. package/src/prover/smt/solver/lp/nla-core.ts +66 -11
  274. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  275. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  276. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  277. package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
  278. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  279. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  280. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  281. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  282. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  283. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  284. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  285. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  286. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  287. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  288. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  289. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  290. package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
  291. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  292. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  293. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  294. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  295. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  296. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  297. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  298. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  299. package/src/prover/smt/solver/macro-finder.ts +530 -0
  300. package/src/prover/smt/solver/mam-compiler.ts +118 -88
  301. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  302. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  303. package/src/prover/smt/solver/max-cliques.ts +105 -0
  304. package/src/prover/smt/solver/maxcore.ts +309 -0
  305. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  306. package/src/prover/smt/solver/maxlex.ts +115 -0
  307. package/src/prover/smt/solver/maxsmt-base.ts +105 -0
  308. package/src/prover/smt/solver/maxsmt.ts +92 -0
  309. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  310. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  311. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  312. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  313. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  314. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  315. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  316. package/src/prover/smt/solver/model-checker.ts +17 -26
  317. package/src/prover/smt/solver/model-evaluator.ts +188 -12
  318. package/src/prover/smt/solver/model-finder.ts +0 -1
  319. package/src/prover/smt/solver/model-generator.ts +59 -30
  320. package/src/prover/smt/solver/model-macro-solver.ts +38 -27
  321. package/src/prover/smt/solver/model-printer.ts +214 -0
  322. package/src/prover/smt/solver/mpf.ts +709 -0
  323. package/src/prover/smt/solver/mus.ts +50 -0
  324. package/src/prover/smt/solver/muz/dl-context.ts +410 -0
  325. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  326. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  327. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  328. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  329. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  330. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  331. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  332. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  333. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  334. package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
  335. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  336. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  337. package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
  338. package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
  339. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  340. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  341. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  342. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  343. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  344. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  345. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  346. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  347. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  348. package/src/prover/smt/solver/nlqsat.ts +484 -0
  349. package/src/prover/smt/solver/nlsat/algebraic.ts +305 -88
  350. package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
  351. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  352. package/src/prover/smt/solver/nlsat/explain.ts +424 -211
  353. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  354. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
  355. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  356. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
  357. package/src/prover/smt/solver/nlsat/solver.ts +282 -69
  358. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  359. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  360. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  361. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -7
  362. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
  363. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  364. package/src/prover/smt/solver/nnf.ts +105 -23
  365. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  366. package/src/prover/smt/solver/occf.ts +97 -0
  367. package/src/prover/smt/solver/opt-context.ts +792 -0
  368. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  369. package/src/prover/smt/solver/opt-pareto.ts +282 -0
  370. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  371. package/src/prover/smt/solver/opt-solver.ts +311 -0
  372. package/src/prover/smt/solver/opt-value.ts +55 -0
  373. package/src/prover/smt/solver/optsmt.ts +692 -0
  374. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  375. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  376. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  377. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  378. package/src/prover/smt/solver/poly-rewriter.ts +202 -57
  379. package/src/prover/smt/solver/probes.ts +511 -0
  380. package/src/prover/smt/solver/propagate-values.ts +37 -21
  381. package/src/prover/smt/solver/proto-model.ts +650 -17
  382. package/src/prover/smt/solver/pull-quant.ts +28 -12
  383. package/src/prover/smt/solver/purify-arith.ts +632 -0
  384. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  385. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  386. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  387. package/src/prover/smt/solver/qe-lite.ts +37 -17
  388. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  389. package/src/prover/smt/solver/qe.ts +1499 -0
  390. package/src/prover/smt/solver/qel.ts +25 -0
  391. package/src/prover/smt/solver/qi-queue.ts +0 -1
  392. package/src/prover/smt/solver/qsat.ts +814 -0
  393. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  394. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  395. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
  396. package/src/prover/smt/solver/quantifier-manager.ts +25 -24
  397. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  398. package/src/prover/smt/solver/random-gen.ts +0 -1
  399. package/src/prover/smt/solver/rational.ts +45 -1
  400. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  401. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  402. package/src/prover/smt/solver/reduce-args.ts +225 -0
  403. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  404. package/src/prover/smt/solver/ref-vector.ts +0 -1
  405. package/src/prover/smt/solver/relevancy.ts +1 -2
  406. package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
  407. package/src/prover/smt/solver/rewriter.ts +475 -36
  408. package/src/prover/smt/solver/rlimit.ts +38 -2
  409. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  410. package/src/prover/smt/solver/sat/big.ts +177 -0
  411. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  412. package/src/prover/smt/solver/sat/clause.ts +203 -0
  413. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  414. package/src/prover/smt/solver/sat/config.ts +122 -0
  415. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  416. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  417. package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
  418. package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
  419. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  420. package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
  421. package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
  422. package/src/prover/smt/solver/sat/probing.ts +170 -0
  423. package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
  424. package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
  425. package/src/prover/smt/solver/sat/scc.ts +142 -0
  426. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  427. package/src/prover/smt/solver/sat/solver.ts +2105 -0
  428. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  429. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  430. package/src/prover/smt/solver/search-tree.ts +284 -0
  431. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  432. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  433. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  434. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  435. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  436. package/src/prover/smt/solver/seq-factory.ts +89 -0
  437. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  438. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  439. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  440. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  441. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  442. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  443. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  444. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  445. package/src/prover/smt/solver/seq-subset.ts +165 -0
  446. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  447. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  448. package/src/prover/smt/solver/smt-kernel.ts +90 -0
  449. package/src/prover/smt/solver/smt-logics.ts +66 -0
  450. package/src/prover/smt/solver/smt-setup.ts +544 -0
  451. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  452. package/src/prover/smt/solver/smtlib-parser.ts +3228 -327
  453. package/src/prover/smt/solver/smtlib-script.ts +1843 -0
  454. package/src/prover/smt/solver/solve-eqs.ts +923 -0
  455. package/src/prover/smt/solver/solver.ts +113 -22
  456. package/src/prover/smt/solver/static-features.ts +314 -0
  457. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  458. package/src/prover/smt/solver/tactic.ts +2012 -0
  459. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  460. package/src/prover/smt/solver/theory-array.ts +1240 -0
  461. package/src/prover/smt/solver/theory-bv.ts +1200 -0
  462. package/src/prover/smt/solver/theory-char.ts +355 -0
  463. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  464. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  465. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  466. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  467. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -5
  468. package/src/prover/smt/solver/theory-lra-final-check.ts +56 -71
  469. package/src/prover/smt/solver/theory-lra-internalize.ts +89 -11
  470. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  471. package/src/prover/smt/solver/theory-lra-propagate.ts +24 -28
  472. package/src/prover/smt/solver/theory-lra-state.ts +6 -22
  473. package/src/prover/smt/solver/theory-lra.ts +188 -2
  474. package/src/prover/smt/solver/theory-pb.ts +933 -0
  475. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  476. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  477. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  478. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  479. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  480. package/src/prover/smt/solver/theory-seq.ts +961 -0
  481. package/src/prover/smt/solver/theory.ts +189 -0
  482. package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
  483. package/src/prover/smt/solver/var-subst.ts +36 -14
  484. package/src/prover/smt/table.ts +3 -2
  485. package/src/prover/smt/types.ts +146 -0
  486. package/src/prover/tlapm/cache.ts +37 -16
  487. package/src/prover/tlapm-library.ts +3208 -0
  488. package/src/prover/verdict.ts +2 -0
  489. package/src/prover/zenon/decide.ts +10 -7
  490. package/src/prover/zenon/encode.ts +0 -2
  491. package/src/prover/zenon/eqrel.ts +0 -2
  492. package/src/prover/zenon/equality-rules.ts +24 -2
  493. package/src/prover/zenon/expr.ts +21 -2
  494. package/src/prover/zenon/index-table.ts +7 -4
  495. package/src/prover/zenon/isar-case.ts +1 -3
  496. package/src/prover/zenon/isar.ts +2 -4
  497. package/src/prover/zenon/llproof.ts +0 -2
  498. package/src/prover/zenon/mltoll.ts +0 -2
  499. package/src/prover/zenon/node.ts +20 -5
  500. package/src/prover/zenon/parse.ts +6 -2
  501. package/src/prover/zenon/phrase.ts +1 -3
  502. package/src/prover/zenon/proof.ts +0 -2
  503. package/src/prover/zenon/propositional-rules.ts +0 -2
  504. package/src/prover/zenon/rules.ts +2 -3
  505. package/src/prover/zenon/search.ts +7 -5
  506. package/src/prover/zenon/tla/functions.ts +0 -2
  507. package/src/prover/zenon/tla/llproof.ts +0 -2
  508. package/src/prover/zenon/tla/records.ts +0 -2
  509. package/src/prover/zenon/tla/rewrites.ts +0 -2
  510. package/src/prover/zenon/tla/sets.ts +7 -8
  511. package/src/prover/zenon/tla/terms.ts +0 -2
  512. package/src/prover/zenon/tla/tla.ts +0 -2
  513. package/src/resolve.ts +625 -189
  514. package/src/runtime.ts +7 -1
  515. package/src/sany/builtins.ts +10 -10
  516. package/src/sany/generation.ts +2 -13
  517. package/src/sany/generator-definitions.ts +3 -1
  518. package/src/sany/generator-expressions.ts +36 -30
  519. package/src/sany/generator-proofs.ts +5 -3
  520. package/src/sany/generator.ts +2 -1
  521. package/src/sany/levels.ts +0 -2
  522. package/src/sany/lexer.ts +3 -3
  523. package/src/sany/linter.ts +0 -2
  524. package/src/sany/modules.ts +4 -2
  525. package/src/sany/nodes.ts +1 -1
  526. package/src/sany/selectors.ts +11 -6
  527. package/src/sany/xml.ts +2 -3
  528. package/src/search.ts +209 -56
  529. package/src/simulate.ts +3 -0
  530. package/src/spec-description.ts +2 -2
  531. package/src/standard-definitions.ts +4 -0
  532. package/src/state-graph.ts +0 -2
  533. package/src/subexpressions.ts +265 -94
  534. package/src/successors.ts +2 -1
  535. package/src/symmetry.ts +3 -3
  536. package/src/tableau.ts +2 -2
  537. package/src/tlc/fingerprint.ts +81 -9
  538. package/src/tlc/jar-data.ts +10 -0
  539. package/src/tlc/messages.ts +3 -3
  540. package/src/tlc/order.ts +14 -3
  541. package/src/tlc/summary.ts +29 -14
  542. package/src/tlc/tlc-operators.ts +3 -1
  543. package/src/tlc/tlcext-operators.ts +61 -16
  544. package/src/tlc/trace-spec.ts +5 -5
  545. package/src/typed-tier.ts +6541 -0
  546. package/src/typescript/types.ts +2 -2
  547. package/src/values.ts +46 -27
  548. package/src/prover/isabelle/isar/statement.ts +0 -52
  549. package/src/prover/smt/solver/z3-license.txt +0 -10
  550. package/src/prover/tlaps-module.ts +0 -510
  551. package/src/prover/zenon/LICENSE +0 -32
@@ -1,9 +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
- evaluateLive,
5
5
  evaluateOnLasso,
6
+ getInterpretedAtoms,
6
7
  toLiveExpression,
8
+ type LiveAtoms,
7
9
  type ScopedExpression,
8
10
  type TemporalProperty,
9
11
  } from "./liveness";
@@ -13,15 +15,18 @@ import {
13
15
  getSolutions,
14
16
  getTermKey,
15
17
  isFulfilling,
18
+ type LiveAction,
19
+ type LiveEnabled,
16
20
  type LiveExpression,
21
+ type LiveState,
17
22
  type Solution,
18
23
  type Tableau,
19
24
  } from "./tableau";
20
25
  import { isSameValue, type Value } from "./values";
21
26
 
22
- export interface LiveSuccessor {
27
+ export interface LiveSuccessor<State = Value[]> {
23
28
  index: number;
24
- state: Value[];
29
+ state: State;
25
30
  }
26
31
 
27
32
  export interface Lasso {
@@ -32,6 +37,7 @@ export interface Lasso {
32
37
 
33
38
  export interface LivenessChecker {
34
39
  branches: number;
40
+ solutions: Solution[];
35
41
  addInitialState: (index: number, state: Value[], tracing?: Environment) => void;
36
42
  addState: (
37
43
  index: number,
@@ -39,13 +45,38 @@ export interface LivenessChecker {
39
45
  successors: LiveSuccessor[],
40
46
  tracing?: Environment,
41
47
  ) => number[] | undefined;
48
+ storeState: (pending: number, index: number) => void;
49
+ getStateCounts: () => number[];
42
50
  findViolation: () => Lasso | undefined;
43
51
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
44
52
  }
45
53
 
46
- interface SearchGraph {
47
- getFingerprint: (successor: LiveSuccessor) => number;
48
- getSuccessors: (index: number, state: Value[]) => LiveSuccessor[];
54
+ export interface LiveGraph<State> {
55
+ branches: number;
56
+ addInitialState: (index: number, state: State) => void;
57
+ // The path to an accepting node the state reaches, if any.
58
+ addState: (
59
+ index: number,
60
+ state: State,
61
+ successors: LiveSuccessor<State>[],
62
+ ) => number[] | undefined;
63
+ storeState: (pending: number, index: number) => void;
64
+ getStateCounts: () => number[];
65
+ findViolation: () => Lasso | undefined;
66
+ }
67
+
68
+ export interface SearchGraph<State> {
69
+ getFingerprint: (successor: LiveSuccessor<State>) => number;
70
+ getSuccessors: (index: number, state: State) => LiveSuccessor<State>[];
71
+ }
72
+
73
+ export interface LiveEvaluation<State> {
74
+ atoms: LiveAtoms<State>;
75
+ // Whether a check's result for a state holds for every step from it.
76
+ isShared: boolean;
77
+ isSame: (left: State, right: State) => boolean;
78
+ // Evaluates the checks of a state the search found from the state at source.
79
+ evaluateFrom: <Result>(source: number | undefined, evaluate: () => Result) => Result;
49
80
  }
50
81
 
51
82
  interface Pool<Data extends Int32Array | Uint8Array> {
@@ -54,8 +85,25 @@ interface Pool<Data extends Int32Array | Uint8Array> {
54
85
  create: (length: number) => Data;
55
86
  }
56
87
 
57
- interface BehaviorGraph {
88
+ // A check reads and fills the state atoms of a state in its row, which starts at offset.
89
+ type Check<State> = (
90
+ state: State,
91
+ row: Int8Array,
92
+ offset: number,
93
+ next: State | undefined,
94
+ ) => boolean;
95
+
96
+ interface BehaviorChecks<State> {
97
+ states: Check<State>[];
98
+ actions: Check<State>[];
99
+ // The state predicates of each tableau node, or, where its checks share results and it has only
100
+ // state atoms and their negations, each atom's id * 2 plus 1 if it must hold.
101
+ nodes: (Check<State>[] | Int32Array)[];
102
+ }
103
+
104
+ interface BehaviorGraph<State> {
58
105
  solution: Solution;
106
+ checks: BehaviorChecks<State>;
59
107
  actionIds: Int32Array;
60
108
  nodeStates: number[];
61
109
  nodeTableaux: number[];
@@ -70,6 +118,7 @@ interface BehaviorGraph {
70
118
  nextSiblings: number[];
71
119
  nodeIds: NodeTable;
72
120
  isDone: boolean[];
121
+ stateCount: number;
73
122
  errorNode: number | undefined;
74
123
  }
75
124
 
@@ -112,14 +161,18 @@ const writeToPool = <Data extends Int32Array | Uint8Array>(
112
161
  pool: Pool<Data>,
113
162
  offset: number,
114
163
  values: ArrayLike<number>,
164
+ start = 0,
165
+ length = values.length - start,
115
166
  ) => {
116
- const end = offset + values.length;
167
+ const end = offset + length;
117
168
  if (end > pool.data.length) {
118
169
  const data = pool.create(Math.max(2 * pool.data.length, end));
119
170
  data.set(pool.data);
120
171
  pool.data = data;
121
172
  }
122
- pool.data.set(values, offset);
173
+ for (let position = 0; position < length; position++) {
174
+ pool.data[offset + position] = values[start + position];
175
+ }
123
176
  pool.length = Math.max(pool.length, end);
124
177
  };
125
178
 
@@ -148,20 +201,20 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
148
201
 
149
202
  const UNWRITTEN = -1;
150
203
 
151
- const isWritten = (behavior: BehaviorGraph, node: number) =>
204
+ const isWritten = <State>(behavior: BehaviorGraph<State>, node: number) =>
152
205
  (behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
153
206
 
154
- const getNodeSuccessors = (behavior: BehaviorGraph, node: number) => {
207
+ const getNodeSuccessors = <State>(behavior: BehaviorGraph<State>, node: number) => {
155
208
  const start = behavior.edgeStarts[node];
156
209
  return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
157
210
  };
158
211
 
159
- const getStateResult = (behavior: BehaviorGraph, node: number, position: number) =>
212
+ const getStateResult = <State>(behavior: BehaviorGraph<State>, node: number, position: number) =>
160
213
  behavior.stateResults.data[
161
214
  behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
162
215
  ] === 1;
163
216
 
164
- const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
217
+ const pushNode = <State>(behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
165
218
  behavior.nodeStates.push(state);
166
219
  behavior.nodeTableaux.push(tableauNode);
167
220
  behavior.edgeStarts.push(UNWRITTEN);
@@ -170,7 +223,7 @@ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) =
170
223
  return behavior.nodeStates.length - 1;
171
224
  };
172
225
 
173
- const getStateNodes = (behavior: BehaviorGraph, state: number) => {
226
+ const getStateNodes = <State>(behavior: BehaviorGraph<State>, state: number) => {
174
227
  const nodes: number[] = [];
175
228
  for (
176
229
  let node = behavior.firstNodes.data[state] ?? NO_NODE;
@@ -190,13 +243,11 @@ const UNVISITED = -1;
190
243
 
191
244
  const MAXIMUM_LINK = Number.MAX_SAFE_INTEGER;
192
245
 
193
- export const createLivenessChecker = (
246
+ const getLiveFormula = (
194
247
  properties: TemporalProperty[],
195
248
  temporals: ScopedExpression[],
196
249
  environment: Environment,
197
- search: SearchGraph,
198
- ): LivenessChecker | undefined => {
199
- if (properties.length === 0) return undefined;
250
+ ) => {
200
251
  const fairness = temporals.map((item) =>
201
252
  toLiveExpression(item.expression, item.scope, environment),
202
253
  );
@@ -206,10 +257,242 @@ export const createLivenessChecker = (
206
257
  const violation = negations.length === 1 ? negations[0] : createJunction("Or", negations);
207
258
  const formula =
208
259
  fairness.length === 0 ? violation : createJunction("And", [...fairness, violation]);
209
- const solutions = getSolutions(formula);
260
+ return { formula, negations };
261
+ };
262
+
263
+ export type LiveAtom = LiveState | LiveEnabled | LiveAction;
264
+
265
+ const getAtomExpressions = (atom: LiveAtom): ScopedExpression[] => {
266
+ switch (atom.kind) {
267
+ case "State":
268
+ return [atom];
269
+ case "Enabled":
270
+ return [{ expression: atom.step, scope: atom.scope }];
271
+ case "Action":
272
+ return [atom.expression, atom.subscript].flatMap((inner) =>
273
+ inner ? [{ expression: inner, scope: atom.scope }] : [],
274
+ );
275
+ }
276
+ };
277
+
278
+ const collectAtoms = (expression: LiveExpression, atoms: Set<LiveAtom>) => {
279
+ switch (expression.kind) {
280
+ case "Boolean":
281
+ return;
282
+ case "State":
283
+ case "Enabled":
284
+ case "Action":
285
+ atoms.add(expression);
286
+ return;
287
+ case "And":
288
+ case "Or":
289
+ expression.operands.forEach((operand) => collectAtoms(operand, atoms));
290
+ return;
291
+ default:
292
+ collectAtoms(expression.body, atoms);
293
+ }
294
+ };
295
+
296
+ // The atoms the checks of the solutions evaluate.
297
+ export const getLiveAtoms = (solutions: Solution[]) => {
298
+ const atoms = new Set<LiveAtom>();
299
+ for (const solution of solutions) {
300
+ [
301
+ ...solution.stateChecks,
302
+ ...solution.actionChecks,
303
+ ...(solution.tableau?.nodes.flatMap((node) => node.statePredicates) ?? []),
304
+ ].forEach((check) => collectAtoms(check, atoms));
305
+ }
306
+ return [...atoms];
307
+ };
308
+
309
+ // The expressions the checks of the solutions evaluate.
310
+ export const getLiveExpressions = (solutions: Solution[]) =>
311
+ getLiveAtoms(solutions).flatMap((atom) =>
312
+ getAtomExpressions(atom).map((item) => item.expression),
313
+ );
314
+
315
+ export const createLivenessChecker = (
316
+ properties: TemporalProperty[],
317
+ temporals: ScopedExpression[],
318
+ environment: Environment,
319
+ search: SearchGraph<Value[]>,
320
+ ): LivenessChecker | undefined => {
321
+ if (properties.length === 0) return undefined;
322
+ const live = getLiveFormula(properties, temporals, environment);
323
+ // A check evaluated once for a state shows what TLC shows when no check repeats an effect. A
324
+ // definition TLC evaluates as it starts repeats nothing, but a scope can bind any definition.
325
+ const formulaAtoms = new Set<LiveAtom>();
326
+ collectAtoms(live.formula, formulaAtoms);
327
+ const checked = [...formulaAtoms].flatMap(getAtomExpressions);
328
+ const isShared = checked.every((item) => item.scope === undefined)
329
+ ? !isExpressionImpure(
330
+ checked.map((item) => item.expression),
331
+ environment,
332
+ "repeated",
333
+ )
334
+ : !hasRepeatedEffects(environment);
335
+ const tracing = { environment, atoms: getInterpretedAtoms(environment) };
336
+ const solutions = getSolutions(live.formula);
337
+ const graph = createLiveGraph(
338
+ solutions,
339
+ {
340
+ atoms: {
341
+ holdsState: (atom, state) => tracing.atoms.holdsState(atom, state),
342
+ holdsAction: (atom, state, next) => tracing.atoms.holdsAction(atom, state, next),
343
+ },
344
+ isShared,
345
+ isSame: isSameState,
346
+ evaluateFrom: (source, evaluate) => {
347
+ environment.runtime.setLivenessSource(source);
348
+ try {
349
+ return evaluate();
350
+ } finally {
351
+ environment.runtime.setLivenessSource(undefined);
352
+ }
353
+ },
354
+ },
355
+ search,
356
+ environment.runtime.version !== "1.7.4",
357
+ );
358
+ const traceWith = <Result>(replay: Environment | undefined, run: () => Result) => {
359
+ if (replay === undefined) return run();
360
+ tracing.atoms = getInterpretedAtoms(replay);
361
+ try {
362
+ return run();
363
+ } finally {
364
+ tracing.atoms = getInterpretedAtoms(environment);
365
+ }
366
+ };
367
+ return {
368
+ branches: graph.branches,
369
+ solutions,
370
+ addInitialState: (index, state, replay) =>
371
+ traceWith(replay, () => graph.addInitialState(index, state)),
372
+ addState: (index, state, successors, replay) =>
373
+ traceWith(replay, () => graph.addState(index, state, successors)),
374
+ storeState: graph.storeState,
375
+ getStateCounts: graph.getStateCounts,
376
+ findViolation: graph.findViolation,
377
+ getViolatedProperties: (path, cycleStart) => [
378
+ ...new Set(
379
+ properties
380
+ .filter(
381
+ (_property, position) =>
382
+ !evaluateOnLasso(live.negations[position].body, path, cycleStart, 0, environment),
383
+ )
384
+ .map((property) => property.name),
385
+ ),
386
+ ],
387
+ };
388
+ };
389
+
390
+ export const createLiveGraph = <State>(
391
+ solutions: Solution[],
392
+ evaluation: LiveEvaluation<State>,
393
+ search: SearchGraph<State>,
394
+ isAcceptingFound: boolean,
395
+ ): LiveGraph<State> => {
210
396
  const actionIds = new Map<string, number>();
211
- const behaviors = solutions.map((solution): BehaviorGraph => ({
397
+ let capacityMultiplier = 1;
398
+ const isShared = evaluation.isShared;
399
+ const atoms = evaluation.atoms;
400
+ const evaluateFrom = evaluation.evaluateFrom;
401
+ const stateAtoms = new Map<LiveState | LiveEnabled, number>();
402
+ const atomsById: (LiveState | LiveEnabled)[] = [];
403
+ const getAtomId = (atom: LiveState | LiveEnabled) => {
404
+ const id = stateAtoms.get(atom) ?? stateAtoms.size;
405
+ stateAtoms.set(atom, id);
406
+ atomsById[id] = atom;
407
+ return id;
408
+ };
409
+ const getLiterals = (expression: LiveExpression): number[] | undefined => {
410
+ if (expression.kind === "State" || expression.kind === "Enabled") {
411
+ return [getAtomId(expression) * 2 + 1];
412
+ }
413
+ if (expression.kind === "Not") {
414
+ const body = expression.body;
415
+ return body.kind === "State" || body.kind === "Enabled" ? [getAtomId(body) * 2] : undefined;
416
+ }
417
+ if (expression.kind !== "And") return undefined;
418
+ const operands = expression.operands.map(getLiterals);
419
+ return operands.every((operand) => operand !== undefined) ? operands.flat() : undefined;
420
+ };
421
+ // The rows of states, one after another, hold whether each state atom holds of a state: 1 or 0,
422
+ // or -1 before it is evaluated.
423
+ const createRows = (count: number) => new Int8Array(count * stateAtoms.size).fill(-1);
424
+ // The edge rows of steps hold the result of each action check, shared by the behaviors that
425
+ // check it.
426
+ const createEdgeRows = (count: number) => new Int8Array(count * actionIds.size).fill(-1);
427
+ // Unless the checks share results, each check evaluates its atoms afresh.
428
+ const runCheck = (
429
+ check: Check<State>,
430
+ state: State,
431
+ row: Int8Array,
432
+ offset: number,
433
+ next?: State,
434
+ ) => (isShared ? check(state, row, offset, next) : check(state, createRows(1), 0, next));
435
+ const compileCheck = (expression: LiveExpression): Check<State> => {
436
+ switch (expression.kind) {
437
+ case "Boolean": {
438
+ const value = expression.value;
439
+ return () => value;
440
+ }
441
+ case "State":
442
+ case "Enabled": {
443
+ const id = getAtomId(expression);
444
+ return (state, row, offset) => {
445
+ if (row[offset + id] === -1) {
446
+ row[offset + id] = atoms.holdsState(expression, state) ? 1 : 0;
447
+ }
448
+ return row[offset + id] === 1;
449
+ };
450
+ }
451
+ case "Action": {
452
+ const enabled = expression.enabled && getAtomId(expression.enabled);
453
+ return (state, row, offset, next) =>
454
+ !(enabled !== undefined && row[offset + enabled] === 0) &&
455
+ next !== undefined &&
456
+ atoms.holdsAction(expression, state, next);
457
+ }
458
+ case "Not": {
459
+ const body = compileCheck(expression.body);
460
+ return (state, row, offset, next) => !body(state, row, offset, next);
461
+ }
462
+ case "And": {
463
+ const operands = expression.operands.map(compileCheck);
464
+ return (state, row, offset, next) =>
465
+ operands.every((operand) => operand(state, row, offset, next));
466
+ }
467
+ case "Or": {
468
+ const operands = expression.operands.map(compileCheck);
469
+ return (state, row, offset, next) =>
470
+ operands.some((operand) => operand(state, row, offset, next));
471
+ }
472
+ case "Next": {
473
+ const body = compileCheck(expression.body);
474
+ return (state, _row, _offset, next) => body(next ?? state, createRows(1), 0, undefined);
475
+ }
476
+ case "Always":
477
+ case "Eventually":
478
+ return () => {
479
+ throw new TlaEvaluationError("TLC cannot evaluate a temporal formula in a single step");
480
+ };
481
+ }
482
+ };
483
+ const behaviors = solutions.map((solution): BehaviorGraph<State> => ({
212
484
  solution,
485
+ checks: {
486
+ states: solution.stateChecks.map(compileCheck),
487
+ actions: solution.actionChecks.map(compileCheck),
488
+ nodes:
489
+ solution.tableau?.nodes.map((node) => {
490
+ const literals = isShared
491
+ ? getLiterals({ kind: "And", operands: node.statePredicates })
492
+ : undefined;
493
+ return literals ? Int32Array.from(literals) : node.statePredicates.map(compileCheck);
494
+ }) ?? [],
495
+ },
213
496
  actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
214
497
  const key = getTermKey(predicate);
215
498
  const actionId = actionIds.get(key) ?? actionIds.size;
@@ -229,85 +512,88 @@ export const createLivenessChecker = (
229
512
  nextSiblings: [],
230
513
  nodeIds: { slots: new Int32Array(3 << 10), size: 0, shift: 22 },
231
514
  isDone: [],
515
+ stateCount: 0,
232
516
  errorNode: undefined,
233
517
  }));
234
- let capacityMultiplier = 1;
235
-
236
- const isShared = !hasRepeatedEffects(environment);
237
- let evaluationEnvironment = environment;
238
- const sharedStates = new Map<Value[], Map<LiveExpression, boolean>>();
239
- const sharedActions = new Map<Value[], Map<Value[], Int8Array>>();
240
- const getStateCache = (state: Value[]) => {
241
- const cache = sharedStates.get(state) ?? new Map<LiveExpression, boolean>();
242
- sharedStates.set(state, cache);
243
- return cache;
244
- };
245
- const evaluateFrom = <Result>(source: number | undefined, evaluate: () => Result) => {
246
- environment.runtime.setLivenessSource(source);
247
- try {
248
- return evaluate();
249
- } finally {
250
- environment.runtime.setLivenessSource(undefined);
251
- }
252
- };
253
- const evaluateState = (predicate: LiveExpression, state: Value[]) =>
254
- evaluateLive(
255
- predicate,
256
- state,
257
- undefined,
258
- evaluationEnvironment,
259
- isShared ? getStateCache(state) : new Map(),
260
- );
261
- const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
262
- evaluateFrom(source, () =>
263
- Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
264
- evaluateState(predicate, state) ? 1 : 0,
265
- ),
266
- );
518
+ const checkState = (
519
+ behavior: BehaviorGraph<State>,
520
+ source: number,
521
+ state: State,
522
+ row: Int8Array,
523
+ offset: number,
524
+ ) =>
525
+ evaluateFrom(source, () => {
526
+ const checks = behavior.checks.states;
527
+ const results = new Uint8Array(checks.length);
528
+ checks.forEach((check, position) => {
529
+ results[position] = runCheck(check, state, row, offset) ? 1 : 0;
530
+ });
531
+ return results;
532
+ });
533
+ // Writes the result of each action check of the step to successor at resultOffset in results.
267
534
  const checkAction = (
268
- behavior: BehaviorGraph,
535
+ behavior: BehaviorGraph<State>,
269
536
  source: number,
270
- state: Value[],
271
- successor: Value[],
537
+ state: State,
538
+ row: Int8Array,
539
+ offset: number,
540
+ successor: State,
541
+ edges: Int8Array,
542
+ edgeOffset: number,
543
+ results: Uint8Array,
544
+ resultOffset: number,
272
545
  ) =>
273
546
  evaluateFrom(source, () => {
274
- const predicates = behavior.solution.actionChecks;
275
- if (!isShared) {
276
- return Uint8Array.from(predicates, (predicate) =>
277
- evaluateLive(predicate, state, successor, evaluationEnvironment, new Map()) ? 1 : 0,
278
- );
279
- }
280
- const stateCache = getStateCache(state);
281
- const results = sharedActions.get(state) ?? new Map<Value[], Int8Array>();
282
- sharedActions.set(state, results);
283
- const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
284
- results.set(successor, known);
285
- return Uint8Array.from(behavior.actionIds, (actionId, position) => {
286
- if (known[actionId] === -1) {
287
- known[actionId] = evaluateLive(
288
- predicates[position],
547
+ const actions = behavior.checks.actions;
548
+ for (let position = 0; position < actions.length; position++) {
549
+ if (!isShared) {
550
+ results[resultOffset + position] = runCheck(
551
+ actions[position],
289
552
  state,
553
+ row,
554
+ offset,
290
555
  successor,
291
- evaluationEnvironment,
292
- stateCache,
293
556
  )
294
557
  ? 1
295
558
  : 0;
559
+ continue;
296
560
  }
297
- return known[actionId];
298
- });
561
+ const edge = edgeOffset + behavior.actionIds[position];
562
+ if (edges[edge] === -1)
563
+ edges[edge] = actions[position](state, row, offset, successor) ? 1 : 0;
564
+ results[resultOffset + position] = edges[edge];
565
+ }
299
566
  });
567
+ const holdsNode = (
568
+ behavior: BehaviorGraph<State>,
569
+ node: number,
570
+ state: State,
571
+ row: Int8Array,
572
+ offset: number,
573
+ ) => {
574
+ const checks = behavior.checks.nodes[node];
575
+ if (!(checks instanceof Int32Array)) {
576
+ return checks.every((check) => runCheck(check, state, row, offset));
577
+ }
578
+ for (let position = 0; position < checks.length; position++) {
579
+ const literal: number = checks[position];
580
+ const cell = offset + (literal >> 1);
581
+ if (row[cell] === -1) row[cell] = atoms.holdsState(atomsById[literal >> 1], state) ? 1 : 0;
582
+ if (row[cell] !== (literal & 1)) return false;
583
+ }
584
+ return true;
585
+ };
300
586
  const isConsistent = (
301
- tableau: Tableau,
587
+ behavior: BehaviorGraph<State>,
302
588
  node: number,
303
589
  source: number | undefined,
304
- state: Value[],
305
- ) =>
306
- evaluateFrom(source, () =>
307
- tableau.nodes[node].statePredicates.every((predicate) => evaluateState(predicate, state)),
308
- );
590
+ state: State,
591
+ row: Int8Array,
592
+ offset: number,
593
+ ) => evaluateFrom(source, () => holdsNode(behavior, node, state, row, offset));
594
+
309
595
  const isAccepting = (tableau: Tableau, node: number) => {
310
- if (environment.runtime.version === "1.7.4") return false;
596
+ if (!isAcceptingFound) return false;
311
597
  const tableauNode = tableau.nodes[node];
312
598
  return (
313
599
  tableauNode.particle.length === 0 &&
@@ -316,14 +602,18 @@ export const createLivenessChecker = (
316
602
  );
317
603
  };
318
604
 
319
- const getNodeId = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
605
+ const getNodeId = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
320
606
  if (!behavior.solution.tableau) return state;
321
607
  const slots = behavior.nodeIds.slots;
322
608
  const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
323
609
  return slots[slot] === 0 ? undefined : slots[slot + 2];
324
610
  };
325
- const recordNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
326
- const node = pushNode(behavior, state, tableauNode);
611
+ const linkNode = (
612
+ behavior: BehaviorGraph<State>,
613
+ state: number,
614
+ tableauNode: number,
615
+ node: number,
616
+ ) => {
327
617
  const table = behavior.nodeIds;
328
618
  if (++table.size * 2 > table.slots.length / 3) {
329
619
  const old = table.slots;
@@ -339,24 +629,43 @@ export const createLivenessChecker = (
339
629
  }
340
630
  }
341
631
  table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
632
+ if (state < 0) return node;
342
633
  const last = behavior.lastNodes.data[state] ?? NO_NODE;
343
634
  if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
344
635
  else behavior.nextSiblings[last] = node;
345
636
  writeToPool(behavior.lastNodes, state, [node]);
346
637
  return node;
347
638
  };
639
+ const hasState = (behavior: BehaviorGraph<State>, state: number) =>
640
+ state < 0
641
+ ? behavior.checks.nodes.some(
642
+ (_checks, tableauNode) => getNodeId(behavior, state, tableauNode) !== undefined,
643
+ )
644
+ : behavior.isDone[state] === true || (behavior.firstNodes.data[state] ?? NO_NODE) !== NO_NODE;
645
+ const recordNode = (behavior: BehaviorGraph<State>, state: number, tableauNode: number) => {
646
+ if (!hasState(behavior, state)) behavior.stateCount++;
647
+ return linkNode(behavior, state, tableauNode, pushNode(behavior, state, tableauNode));
648
+ };
649
+ // The action results of the edge to each target are at its position in actions.
348
650
  const writeNode = (
349
- behavior: BehaviorGraph,
651
+ behavior: BehaviorGraph<State>,
350
652
  node: number,
351
653
  targets: number[],
352
- actions: Uint8Array[],
654
+ actionResults: Uint8Array,
655
+ actions: number[],
353
656
  stateResults: Uint8Array,
354
657
  ) => {
355
658
  const start = behavior.edgeTargets.length;
356
659
  const actionCount = behavior.solution.actionChecks.length;
357
660
  writeToPool(behavior.edgeTargets, start, targets);
358
- actions.forEach((results, position) =>
359
- writeToPool(behavior.edgeActions, (start + position) * actionCount, results),
661
+ actions.forEach((position, edge) =>
662
+ writeToPool(
663
+ behavior.edgeActions,
664
+ (start + edge) * actionCount,
665
+ actionResults,
666
+ position * actionCount,
667
+ actionCount,
668
+ ),
360
669
  );
361
670
  writeToPool(
362
671
  behavior.stateResults,
@@ -368,57 +677,68 @@ export const createLivenessChecker = (
368
677
  };
369
678
 
370
679
  // 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.
371
- const getSuccessorSet = (index: number, state: Value[], successors: LiveSuccessor[]) => {
372
- let successorSlots = Array.from<LiveSuccessor | undefined>({
373
- length: SUCCESSOR_CAPACITY * capacityMultiplier,
374
- });
375
- let successorCount = 0;
376
- const insertSuccessor = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
680
+ // Each slot holds a candidate's position plus one, or 0 when it is empty.
681
+ const successorSet = { slots: new Int32Array(0) };
682
+ const getSuccessorSet = (index: number, state: State, successors: LiveSuccessor<State>[]) => {
683
+ const candidates = [...successors, { index, state }];
684
+ const capacity = SUCCESSOR_CAPACITY * capacityMultiplier;
685
+ successorSet.slots =
686
+ successorSet.slots.length === capacity
687
+ ? successorSet.slots.fill(0)
688
+ : new Int32Array(capacity);
689
+ const insert = (position: number) => {
690
+ const slots = successorSet.slots;
691
+ const candidate = candidates[position];
377
692
  for (
378
- let slot = (search.getFingerprint(successor) & 0x7fffffff) % slots.length;
693
+ let slot = (search.getFingerprint(candidate) & 0x7fffffff) % slots.length;
379
694
  ;
380
695
  slot = (slot + 1) % slots.length
381
696
  ) {
382
697
  const entry = slots[slot];
383
- if (entry === undefined) {
384
- slots[slot] = successor;
698
+ if (entry === 0) {
699
+ slots[slot] = position + 1;
385
700
  return true;
386
701
  }
387
- if (entry.index === successor.index && isSameState(entry.state, successor.state))
702
+ const stored = candidates[entry - 1];
703
+ if (stored.index === candidate.index && evaluation.isSame(stored.state, candidate.state))
388
704
  return false;
389
705
  }
390
706
  };
391
- const addSuccessor = (successor: LiveSuccessor) => {
392
- if (successorCount >= successorSlots.length >> 1) {
393
- const old = successorSlots;
394
- successorSlots = Array.from<LiveSuccessor | undefined>({ length: 2 * old.length + 1 });
395
- for (const entry of old) if (entry) insertSuccessor(successorSlots, entry);
707
+ let count = 0;
708
+ for (let position = 0; position < candidates.length; position++) {
709
+ if (count >= successorSet.slots.length >> 1) {
710
+ const old = successorSet.slots;
711
+ successorSet.slots = new Int32Array(2 * old.length + 1);
712
+ for (const entry of old) if (entry !== 0) insert(entry - 1);
396
713
  }
397
- if (insertSuccessor(successorSlots, successor)) successorCount++;
398
- };
399
- successors.forEach(addSuccessor);
400
- addSuccessor({ index, state });
401
- if (successorSlots.length > SUCCESSOR_CAPACITY * capacityMultiplier) capacityMultiplier++;
402
- return successorSlots.filter((entry): entry is LiveSuccessor => entry !== undefined);
714
+ if (insert(position)) count++;
715
+ }
716
+ if (successorSet.slots.length > capacity) capacityMultiplier++;
717
+ const set: LiveSuccessor<State>[] = [];
718
+ for (const entry of successorSet.slots) if (entry !== 0) set.push(candidates[entry - 1]);
719
+ return set;
403
720
  };
404
721
 
405
722
  const expandLate = (
406
- behavior: BehaviorGraph,
723
+ behavior: BehaviorGraph<State>,
407
724
  tableau: Tableau,
408
- state: Value[],
725
+ state: State,
409
726
  index: number,
410
727
  node: number,
728
+ row: Int8Array,
729
+ offset: number,
411
730
  ) => {
412
- const stateResults = checkState(behavior, index, state);
731
+ const stateResults = checkState(behavior, index, state, row, offset);
413
732
  const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
414
- const actions: Uint8Array[] = [];
733
+ const actionCount = behavior.checks.actions.length;
734
+ const actions: number[] = [];
415
735
  const successors: number[] = [];
416
- const selfActions =
417
- tableauNode.successors.length > 0
418
- ? checkAction(behavior, index, state, state)
419
- : new Uint8Array(0);
736
+ const selfResults = new Uint8Array(actionCount);
737
+ if (tableauNode.successors.length > 0) {
738
+ checkAction(behavior, index, state, row, offset, state, createEdgeRows(1), 0, selfResults, 0);
739
+ }
420
740
  for (const next of tableauNode.successors) {
421
- if (!isConsistent(tableau, next, index, state)) continue;
741
+ if (!isConsistent(behavior, next, index, state, row, offset)) continue;
422
742
  if (
423
743
  isAccepting(tableau, next) &&
424
744
  behavior.errorNode === undefined &&
@@ -431,60 +751,96 @@ export const createLivenessChecker = (
431
751
  if (existing !== undefined && successors.includes(existing)) continue;
432
752
  const target = existing ?? recordNode(behavior, index, next);
433
753
  successors.push(target);
434
- actions.push(selfActions);
435
- if (existing === undefined) expandLate(behavior, tableau, state, index, target);
754
+ actions.push(0);
755
+ if (existing === undefined) expandLate(behavior, tableau, state, index, target, row, offset);
436
756
  }
437
- for (const successor of search.getSuccessors(index, state)) {
438
- const successorActions = checkAction(behavior, index, state, successor.state);
757
+ const nextStates = search.getSuccessors(index, state);
758
+ // The results of the step to the state itself come first, then those of each successor.
759
+ const actionResults = new Uint8Array((nextStates.length + 1) * actionCount);
760
+ actionResults.set(selfResults);
761
+ const edges = createEdgeRows(nextStates.length);
762
+ nextStates.forEach((successor, position) => {
763
+ const successorRow = createRows(1);
764
+ checkAction(
765
+ behavior,
766
+ index,
767
+ state,
768
+ row,
769
+ offset,
770
+ successor.state,
771
+ edges,
772
+ position * actionIds.size,
773
+ actionResults,
774
+ (position + 1) * actionCount,
775
+ );
439
776
  const isDone = behavior.isDone[successor.index] === true;
440
777
  for (const next of tableauNode.successors) {
441
- if (!isConsistent(tableau, next, index, successor.state)) continue;
442
- // Deviation from TLC: TLC records the node of a successor the search never stored, which it never expands.
443
- if (successor.index === -1) continue;
778
+ if (!isConsistent(behavior, next, index, successor.state, successorRow, 0)) continue;
444
779
  const existing = getNodeId(behavior, successor.index, next);
445
780
  if (existing !== undefined && successors.includes(existing)) continue;
446
781
  const target = existing ?? recordNode(behavior, successor.index, next);
447
782
  successors.push(target);
448
- actions.push(successorActions);
783
+ actions.push(position + 1);
449
784
  if (existing === undefined && isDone) {
450
- expandLate(behavior, tableau, successor.state, successor.index, target);
785
+ expandLate(behavior, tableau, successor.state, successor.index, target, successorRow, 0);
451
786
  }
452
787
  }
788
+ });
789
+ if (successors.length > 0) {
790
+ writeNode(behavior, node, successors, actionResults, actions, stateResults);
453
791
  }
454
- if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
455
792
  };
456
793
 
457
794
  const addTableauState = (
458
- behavior: BehaviorGraph,
795
+ behavior: BehaviorGraph<State>,
459
796
  tableau: Tableau,
460
- set: LiveSuccessor[],
461
- actionResults: Uint8Array[],
797
+ set: LiveSuccessor<State>[],
798
+ rows: Int8Array,
799
+ actionResults: Uint8Array,
462
800
  stateResults: Uint8Array,
463
801
  index: number,
464
802
  ) => {
465
- const consistency = tableau.nodes.map((_tableauNode, node) =>
466
- set.map((successor) => isConsistent(tableau, node, index, successor.state)),
467
- );
803
+ const atomCount = stateAtoms.size;
804
+ // Whether each successor is consistent with each tableau node, node by node.
805
+ const consistency = new Uint8Array(tableau.nodes.length * set.length);
806
+ evaluateFrom(index, () => {
807
+ for (let node = 0; node < tableau.nodes.length; node++) {
808
+ for (let position = 0; position < set.length; position++) {
809
+ if (holdsNode(behavior, node, set[position].state, rows, position * atomCount)) {
810
+ consistency[node * set.length + position] = 1;
811
+ }
812
+ }
813
+ }
814
+ });
815
+ if (!hasState(behavior, index)) behavior.stateCount++;
468
816
  behavior.isDone[index] = true;
469
817
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
470
818
  for (const node of getStateNodes(behavior, index)) {
471
819
  const successors: number[] = [];
472
- const actions: Uint8Array[] = [];
820
+ const actions: number[] = [];
473
821
  set.forEach((successor, position) => {
474
822
  const isDone = behavior.isDone[successor.index] === true;
475
823
  for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
476
- if (!consistency[next][position]) continue;
824
+ if (consistency[next * set.length + position] === 0) continue;
477
825
  const existing = getNodeId(behavior, successor.index, next);
478
826
  if (existing !== undefined && successors.includes(existing)) continue;
479
827
  const target = existing ?? recordNode(behavior, successor.index, next);
480
828
  successors.push(target);
481
- actions.push(actionResults[position]);
829
+ actions.push(position);
482
830
  if (existing === undefined && isDone) {
483
- expandLate(behavior, tableau, successor.state, successor.index, target);
831
+ expandLate(
832
+ behavior,
833
+ tableau,
834
+ successor.state,
835
+ successor.index,
836
+ target,
837
+ rows,
838
+ position * atomCount,
839
+ );
484
840
  }
485
841
  }
486
842
  });
487
- writeNode(behavior, node, successors, actions, stateResults);
843
+ writeNode(behavior, node, successors, actionResults, actions, stateResults);
488
844
  }
489
845
  return behavior.errorNode === undefined
490
846
  ? undefined
@@ -492,24 +848,25 @@ export const createLivenessChecker = (
492
848
  };
493
849
 
494
850
  const addPlainState = (
495
- behavior: BehaviorGraph,
496
- set: LiveSuccessor[],
497
- actionResults: Uint8Array[],
851
+ behavior: BehaviorGraph<State>,
852
+ set: LiveSuccessor<State>[],
853
+ actionResults: Uint8Array,
498
854
  stateResults: Uint8Array,
499
855
  index: number,
500
856
  ) => {
501
857
  while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
502
858
  const successors: number[] = [];
503
- const actions: Uint8Array[] = [];
859
+ const actions: number[] = [];
504
860
  set.forEach((successor, position) => {
505
861
  if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
506
862
  successors.push(successor.index);
507
- actions.push(actionResults[position]);
863
+ actions.push(position);
508
864
  });
509
- writeNode(behavior, index, successors, actions, stateResults);
865
+ if (!isWritten(behavior, index)) behavior.stateCount++;
866
+ writeNode(behavior, index, successors, actionResults, actions, stateResults);
510
867
  };
511
868
 
512
- const getPath = (behavior: BehaviorGraph, target: number) => {
869
+ const getPath = (behavior: BehaviorGraph<State>, target: number) => {
513
870
  if (behavior.initial.includes(target)) return [target];
514
871
  const parents = new Map<number, number>();
515
872
  const queue: number[] = [];
@@ -535,7 +892,7 @@ export const createLivenessChecker = (
535
892
  throw new TlaEvaluationError(`Couldn't re-create liveness trace (path) starting at: ${target}`);
536
893
  };
537
894
 
538
- const getStatePath = (behavior: BehaviorGraph, target: number) =>
895
+ const getStatePath = (behavior: BehaviorGraph<State>, target: number) =>
539
896
  removeRepeats(
540
897
  getPath(behavior, target)
541
898
  .reverse()
@@ -543,7 +900,7 @@ export const createLivenessChecker = (
543
900
  );
544
901
 
545
902
  const findLassoInModel = (
546
- behavior: BehaviorGraph,
903
+ behavior: BehaviorGraph<State>,
547
904
  model: Solution["models"][number],
548
905
  ): Lasso | undefined => {
549
906
  const solution = behavior.solution;
@@ -768,59 +1125,80 @@ export const createLivenessChecker = (
768
1125
 
769
1126
  return {
770
1127
  branches: behaviors.length,
771
- addInitialState: (index, state, tracing) => {
772
- evaluationEnvironment = tracing ?? environment;
773
- sharedStates.clear();
774
- sharedActions.clear();
775
- try {
776
- for (const behavior of behaviors) {
777
- const tableau = behavior.solution.tableau;
778
- if (!tableau) {
779
- behavior.initial.push(index);
780
- continue;
781
- }
782
- for (let node = 0; node < tableau.initialCount; node++) {
783
- if (!isConsistent(tableau, node, undefined, state)) continue;
784
- behavior.initial.push(
785
- getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
786
- );
787
- }
1128
+ addInitialState: (index, state) => {
1129
+ const row = createRows(1);
1130
+ for (const behavior of behaviors) {
1131
+ const tableau = behavior.solution.tableau;
1132
+ if (!tableau) {
1133
+ behavior.initial.push(index);
1134
+ continue;
1135
+ }
1136
+ for (let node = 0; node < tableau.initialCount; node++) {
1137
+ if (!isConsistent(behavior, node, undefined, state, row, 0)) continue;
1138
+ behavior.initial.push(
1139
+ getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
1140
+ );
788
1141
  }
789
- } finally {
790
- evaluationEnvironment = environment;
791
1142
  }
792
1143
  },
793
- addState: (index, state, successors, tracing) => {
794
- evaluationEnvironment = tracing ?? environment;
795
- sharedStates.clear();
796
- sharedActions.clear();
797
- try {
798
- const set = getSuccessorSet(index, state, successors);
799
- for (const behavior of behaviors) {
800
- const actionResults = set.map((successor) =>
801
- checkAction(behavior, index, state, successor.state),
802
- );
803
- const stateResults = checkState(behavior, index, state);
804
- const tableau = behavior.solution.tableau;
805
- if (!tableau) {
806
- addPlainState(behavior, set, actionResults, stateResults, index);
807
- continue;
808
- }
809
- const accepted = addTableauState(
1144
+ addState: (index, state, successors) => {
1145
+ const set = getSuccessorSet(index, state, successors);
1146
+ const rows = createRows(set.length);
1147
+ // The set holds the state itself, as a successor of the same index.
1148
+ const offset = set.findIndex((successor) => successor.index === index) * stateAtoms.size;
1149
+ const edges = createEdgeRows(set.length);
1150
+ for (const behavior of behaviors) {
1151
+ const actionCount = behavior.checks.actions.length;
1152
+ const actionResults = new Uint8Array(set.length * actionCount);
1153
+ set.forEach((successor, position) =>
1154
+ checkAction(
810
1155
  behavior,
811
- tableau,
812
- set,
813
- actionResults,
814
- stateResults,
815
1156
  index,
816
- );
817
- if (accepted) return accepted;
1157
+ state,
1158
+ rows,
1159
+ offset,
1160
+ successor.state,
1161
+ edges,
1162
+ position * actionIds.size,
1163
+ actionResults,
1164
+ position * actionCount,
1165
+ ),
1166
+ );
1167
+ const stateResults = checkState(behavior, index, state, rows, offset);
1168
+ const tableau = behavior.solution.tableau;
1169
+ if (!tableau) {
1170
+ addPlainState(behavior, set, actionResults, stateResults, index);
1171
+ continue;
1172
+ }
1173
+ const accepted = addTableauState(
1174
+ behavior,
1175
+ tableau,
1176
+ set,
1177
+ rows,
1178
+ actionResults,
1179
+ stateResults,
1180
+ index,
1181
+ );
1182
+ if (accepted) return accepted;
1183
+ }
1184
+ return undefined;
1185
+ },
1186
+ storeState: (pending, index) => {
1187
+ for (const behavior of behaviors) {
1188
+ const tableau = behavior.solution.tableau;
1189
+ if (!tableau) continue;
1190
+ const nodes: number[] = [];
1191
+ for (let tableauNode = 0; tableauNode < tableau.nodes.length; tableauNode++) {
1192
+ const node = getNodeId(behavior, pending, tableauNode);
1193
+ if (node !== undefined) nodes.push(node);
1194
+ }
1195
+ for (const node of nodes.sort((left, right) => left - right)) {
1196
+ behavior.nodeStates[node] = index;
1197
+ linkNode(behavior, index, behavior.nodeTableaux[node], node);
818
1198
  }
819
- return undefined;
820
- } finally {
821
- evaluationEnvironment = environment;
822
1199
  }
823
1200
  },
1201
+ getStateCounts: () => behaviors.map((behavior) => behavior.stateCount),
824
1202
  findViolation: () => {
825
1203
  for (const behavior of behaviors) {
826
1204
  for (const model of behavior.solution.models) {
@@ -830,15 +1208,5 @@ export const createLivenessChecker = (
830
1208
  }
831
1209
  return undefined;
832
1210
  },
833
- getViolatedProperties: (path, cycleStart) => [
834
- ...new Set(
835
- properties
836
- .filter(
837
- (_property, position) =>
838
- !evaluateOnLasso(negations[position].body, path, cycleStart, 0, environment),
839
- )
840
- .map((property) => property.name),
841
- ),
842
- ],
843
1211
  };
844
1212
  };