tla-ts 0.0.9 → 0.0.10-dev.09e53c2a6

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