tla-ts 0.0.10-dev.b4a856304 → 0.0.10-dev.d618a2d79

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