tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479

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