tla-ts 0.0.10-dev.28c823e4b → 0.0.10-dev.37a75eb5b

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