tla-ts 0.0.10-dev.28c823e4b → 0.0.10-dev.4a2a53c48

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