tla-ts 0.0.4-dev.702eb98 → 0.0.4-dev.7714e32

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 (382) hide show
  1. package/README.md +32 -6
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +27 -27
  5. package/dist/deciders.js +34 -34
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +12 -14
  8. package/dist/index.d.ts +12 -14
  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 +516 -25
  15. package/dist/prove.js +518 -27
  16. package/dist/run.cjs +45 -0
  17. package/dist/run.js +45 -0
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +76 -86
  21. package/dist/transfer.js +73 -83
  22. package/dist/worker.cjs +6 -6
  23. package/dist/worker.js +6 -6
  24. package/package.json +1 -1
  25. package/src/ast.ts +2 -2
  26. package/src/bags.ts +22 -23
  27. package/src/builtins.ts +16 -8
  28. package/src/check.ts +131 -1154
  29. package/src/{cli-options.ts → cli/options.ts} +54 -9
  30. package/src/cli/run.ts +63 -0
  31. package/src/cli/shared.ts +106 -0
  32. package/src/cli/tlapm.ts +374 -0
  33. package/src/{run-cli.ts → cli/tlc.ts} +112 -761
  34. package/src/cli/xml-exporter.ts +221 -0
  35. package/src/cli.ts +1 -1
  36. package/src/codegen.ts +17 -15
  37. package/src/config.ts +5 -5
  38. package/src/dependencies.ts +4 -6
  39. package/src/environment.ts +55 -60
  40. package/src/errors.ts +12 -36
  41. package/src/evaluate.ts +81 -101
  42. package/src/exit-codes.ts +1 -1
  43. package/src/fingerprints.ts +3 -3
  44. package/src/index.ts +2 -2
  45. package/src/instances.ts +56 -46
  46. package/src/java-overrides.ts +79 -41
  47. package/src/json.ts +31 -36
  48. package/src/levels.ts +10 -13
  49. package/src/{live-check.ts → liveness-checker.ts} +169 -142
  50. package/src/liveness.ts +38 -34
  51. package/src/obligations/action.ts +58 -105
  52. package/src/obligations/{anon.ts → anonymize.ts} +44 -52
  53. package/src/obligations/equality.ts +260 -0
  54. package/src/obligations/expression.ts +42 -530
  55. package/src/obligations/format.ts +7 -8
  56. package/src/obligations/generate.ts +93 -783
  57. package/src/obligations/index.ts +23 -23
  58. package/src/obligations/levels.ts +38 -44
  59. package/src/obligations/module.ts +106 -729
  60. package/src/obligations/normalize.ts +554 -0
  61. package/src/obligations/operators.ts +176 -0
  62. package/src/obligations/pragma.ts +35 -29
  63. package/src/obligations/printer.ts +98 -209
  64. package/src/obligations/proof.ts +0 -1
  65. package/src/obligations/regroup.ts +100 -0
  66. package/src/obligations/simplify.ts +668 -0
  67. package/src/obligations/source.ts +92 -192
  68. package/src/obligations/{deref.ts → subexpression.ts} +82 -113
  69. package/src/obligations/substitution.ts +261 -0
  70. package/src/obligations/temporal.ts +32 -30
  71. package/src/obligations/tuples.ts +37 -53
  72. package/src/parallel-worker.ts +37 -33
  73. package/src/parallel.ts +30 -24
  74. package/src/parser.ts +67 -74
  75. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  76. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  77. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  78. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  79. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  80. package/src/{prove → prover}/decide-pool.ts +14 -19
  81. package/src/{prove → prover}/deciders.ts +7 -1
  82. package/src/{obligations/pickle.ts → prover/first-order.ts} +79 -4
  83. package/src/{prove → prover}/isabelle/decide.ts +3 -6
  84. package/src/{prove → prover}/isabelle/encode.ts +106 -138
  85. package/src/{prove → prover}/isabelle/isar/inner-syntax.ts +1 -1
  86. package/src/{prove → prover}/isabelle/isar/method.ts +3 -3
  87. package/src/{prove → prover}/isabelle/isar/type-check.ts +1 -1
  88. package/src/{prove → prover}/isabelle/provers/blast/blast.ts +1 -1
  89. package/src/{prove → prover}/isabelle/provers/blast/branch.ts +1 -1
  90. package/src/{prove → prover}/isabelle/provers/blast/term.ts +3 -4
  91. package/src/{prove → prover}/isabelle/provers/clasimp.ts +1 -1
  92. package/src/{prove → prover}/isabelle/provers/classical.ts +3 -3
  93. package/src/{prove → prover}/isabelle/provers/hypsubst.ts +1 -9
  94. package/src/{prove → prover}/isabelle/pure/conv.ts +1 -1
  95. package/src/{prove → prover}/isabelle/pure/drule.ts +2 -2
  96. package/src/{prove → prover}/isabelle/pure/envir.ts +3 -35
  97. package/src/{prove → prover}/isabelle/pure/logic.ts +4 -76
  98. package/src/{prove → prover}/isabelle/pure/name.ts +1 -13
  99. package/src/{prove → prover}/isabelle/pure/net.ts +2 -49
  100. package/src/{prove → prover}/isabelle/pure/pattern.ts +3 -22
  101. package/src/{prove → prover}/isabelle/pure/raw-simplifier.ts +3 -18
  102. package/src/{prove → prover}/isabelle/pure/seq.ts +0 -23
  103. package/src/{prove → prover}/isabelle/pure/simplifier.ts +2 -8
  104. package/src/{prove → prover}/isabelle/pure/table.ts +1 -8
  105. package/src/{prove → prover}/isabelle/pure/tactic.ts +5 -113
  106. package/src/{prove → prover}/isabelle/pure/tactical.ts +1 -84
  107. package/src/{prove → prover}/isabelle/pure/term-ord.ts +1 -55
  108. package/src/{prove → prover}/isabelle/pure/term.ts +8 -128
  109. package/src/{prove → prover}/isabelle/pure/thm.ts +4 -27
  110. package/src/{prove → prover}/isabelle/pure/type.ts +0 -12
  111. package/src/{prove → prover}/isabelle/pure/unify.ts +1 -1
  112. package/src/{prove → prover}/isabelle/tla/classical-setup.ts +1 -1
  113. package/src/{prove → prover}/ocaml.ts +1 -1
  114. package/src/{prove → prover}/prep/action.ts +54 -66
  115. package/src/{prove → prover}/prep/enabled-axioms.ts +2 -2
  116. package/src/{prove → prover}/prep/fingerprint.ts +3 -3
  117. package/src/{prove → prover}/prep/level-comparison.ts +15 -38
  118. package/src/{prove → prover}/prep/md5.ts +2 -9
  119. package/src/{prove/prep/pragma.ts → prover/prep/methods.ts} +4 -4
  120. package/src/prover/prep/normalize.ts +309 -0
  121. package/src/{prove → prover}/prove-worker.ts +4 -11
  122. package/src/prover/prove.ts +492 -0
  123. package/src/{prove → prover}/ptl/encode.ts +19 -31
  124. package/src/{prove → prover}/smt/axioms.ts +78 -79
  125. package/src/{prove → prover}/smt/data.ts +16 -45
  126. package/src/{prove → prover}/smt/encode.ts +134 -28
  127. package/src/{prove → prover}/smt/extensionality.ts +14 -12
  128. package/src/{prove → prover}/smt/flatten.ts +3 -18
  129. package/src/{prove → prover}/smt/format.ts +14 -3
  130. package/src/{prove → prover}/smt/instances.ts +4 -5
  131. package/src/{prove → prover}/smt/rewrite.ts +41 -59
  132. package/src/{prove → prover}/smt/solver/ast-util.ts +0 -56
  133. package/src/{prove → prover}/smt/solver/case-split-queue.ts +1 -1
  134. package/src/{prove → prover}/smt/solver/enode.ts +1 -1
  135. package/src/{prove → prover}/smt/solver/lp/dep-intervals.ts +0 -14
  136. package/src/{prove → prover}/smt/solver/model-macro-solver.ts +1 -1
  137. package/src/{prove → prover}/smt/solver/nlsat/algebraic.ts +3 -3
  138. package/src/{prove → prover}/smt/solver/nlsat/atoms.ts +1 -1
  139. package/src/{prove → prover}/smt/solver/nlsat/explain.ts +1 -1
  140. package/src/{prove → prover}/smt/solver/nlsat/interval-set.ts +1 -1
  141. package/src/{prove → prover}/smt/solver/nlsat/levelwise.ts +4 -7
  142. package/src/{prove → prover}/smt/solver/nlsat/polynomial.ts +4 -4
  143. package/src/{prove → prover}/smt/solver/nlsat/upolynomial.ts +2 -2
  144. package/src/{prove → prover}/smt/solver/pattern-inference.ts +1 -1
  145. package/src/{prove → prover}/smt/solver/relevancy.ts +2 -2
  146. package/src/{prove → prover}/smt/solver/rewriter.ts +1 -1
  147. package/src/{prove → prover}/smt/solver/solver.ts +2 -2
  148. package/src/prover/tlapm/cache.ts +236 -0
  149. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  150. package/src/{prove → prover}/tlapm/tlapm.ts +1 -2
  151. package/src/prover/verdict.ts +13 -0
  152. package/src/{prove → prover}/zenon/decide.ts +5 -11
  153. package/src/{prove → prover}/zenon/encode.ts +40 -106
  154. package/src/{prove → prover}/zenon/eqrel.ts +1 -1
  155. package/src/{prove → prover}/zenon/equality-rules.ts +1 -1
  156. package/src/{prove → prover}/zenon/expr.ts +2 -2
  157. package/src/{prove → prover}/zenon/index-table.ts +1 -1
  158. package/src/{prove → prover}/zenon/isar.ts +1 -1
  159. package/src/{prove → prover}/zenon/llproof.ts +1 -1
  160. package/src/{prove → prover}/zenon/mltoll.ts +1 -1
  161. package/src/{prove → prover}/zenon/node.ts +1 -1
  162. package/src/{prove → prover}/zenon/search.ts +1 -1
  163. package/src/{prove → prover}/zenon/tla/terms.ts +1 -20
  164. package/src/{prove → prover}/zenon/tla/tla.ts +1 -1
  165. package/src/randomization.ts +19 -24
  166. package/src/resolve.ts +15 -22
  167. package/src/runtime.ts +8 -8
  168. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  169. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  170. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  171. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  172. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  173. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  174. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  175. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  176. package/src/{sany-report.ts → sany/report.ts} +16 -17
  177. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  178. package/src/{sany-source.ts → sany/source.ts} +6 -7
  179. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  180. package/src/search.ts +969 -0
  181. package/src/spec-description.ts +26 -20
  182. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  183. package/src/standard-modules.ts +16 -20
  184. package/src/state-graph.ts +9 -8
  185. package/src/substitution-levels.ts +2 -2
  186. package/src/successors.ts +16 -19
  187. package/src/symmetry.ts +1 -1
  188. package/src/tableau.ts +6 -7
  189. package/src/tlc/fingerprint.ts +214 -0
  190. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  191. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  192. package/src/{tlc-random.ts → tlc/random.ts} +3 -213
  193. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  194. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  195. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  196. package/src/transfer.ts +32 -32
  197. package/src/values.ts +72 -67
  198. package/src/worker.ts +1 -4
  199. package/dist/run-cli.cjs +0 -38
  200. package/dist/run-cli.js +0 -38
  201. package/src/canonical.ts +0 -40
  202. package/src/obligations/ctx.ts +0 -64
  203. package/src/prove/prep/defs.ts +0 -27
  204. package/src/prove/prep/elab.ts +0 -156
  205. package/src/prove/prep/enabled.ts +0 -43
  206. package/src/prove/prep/flatten.ts +0 -70
  207. package/src/prove/prep/trivial.ts +0 -22
  208. package/src/prove/prove.ts +0 -417
  209. package/src/prove/smt/axiomatize.ts +0 -69
  210. package/src/prove/smt/simplify.ts +0 -57
  211. package/src/prove/verdict.ts +0 -13
  212. package/src/standard-ranges.ts +0 -116
  213. package/src/value-sources.ts +0 -29
  214. /package/src/{prove → prover}/isabelle/LICENSE +0 -0
  215. /package/src/{prove → prover}/isabelle/LICENSE-tlapm +0 -0
  216. /package/src/{prove → prover}/isabelle/isar/proof.ts +0 -0
  217. /package/src/{prove → prover}/isabelle/isar/statement.ts +0 -0
  218. /package/src/{prove → prover}/isabelle/isar/theory.ts +0 -0
  219. /package/src/{prove → prover}/isabelle/provers/blast/prove.ts +0 -0
  220. /package/src/{prove → prover}/isabelle/provers/blast/rules.ts +0 -0
  221. /package/src/{prove → prover}/isabelle/provers/blast/state.ts +0 -0
  222. /package/src/{prove → prover}/isabelle/pure/bicompose.ts +0 -0
  223. /package/src/{prove → prover}/isabelle/pure/consts.ts +0 -0
  224. /package/src/{prove → prover}/isabelle/pure/goal.ts +0 -0
  225. /package/src/{prove → prover}/isabelle/pure/interrupt.ts +0 -0
  226. /package/src/{prove → prover}/isabelle/pure/list.ts +0 -0
  227. /package/src/{prove → prover}/isabelle/pure/object-logic.ts +0 -0
  228. /package/src/{prove → prover}/isabelle/pure/rewriter.ts +0 -0
  229. /package/src/{prove → prover}/isabelle/pure/search.ts +0 -0
  230. /package/src/{prove → prover}/isabelle/pure/variable.ts +0 -0
  231. /package/src/{prove → prover}/isabelle/tla/context.ts +0 -0
  232. /package/src/{prove → prover}/isabelle/tla/logic-data.ts +0 -0
  233. /package/src/{prove → prover}/isabelle/tla/logic.ts +0 -0
  234. /package/src/{prove → prover}/isabelle/tla/simpdata.ts +0 -0
  235. /package/src/{prove → prover}/isabelle/tools/intuitionistic.ts +0 -0
  236. /package/src/{prove → prover}/ptl/decide.ts +0 -0
  237. /package/src/{prove → prover}/ptl/sat.ts +0 -0
  238. /package/src/{prove → prover}/ptl/tableau.ts +0 -0
  239. /package/src/{prove → prover}/smt/context.ts +0 -0
  240. /package/src/{prove → prover}/smt/solver/act-cache.ts +0 -0
  241. /package/src/{prove → prover}/smt/solver/arith-rewriter.ts +0 -0
  242. /package/src/{prove → prover}/smt/solver/array.ts +0 -0
  243. /package/src/{prove → prover}/smt/solver/asserted-formulas.ts +0 -0
  244. /package/src/{prove → prover}/smt/solver/ast-lt.ts +0 -0
  245. /package/src/{prove → prover}/smt/solver/ast.ts +0 -0
  246. /package/src/{prove → prover}/smt/solver/auf-solver.ts +0 -0
  247. /package/src/{prove → prover}/smt/solver/cg-table.ts +0 -0
  248. /package/src/{prove → prover}/smt/solver/clause.ts +0 -0
  249. /package/src/{prove → prover}/smt/solver/conflict-resolution.ts +0 -0
  250. /package/src/{prove → prover}/smt/solver/context.ts +0 -0
  251. /package/src/{prove → prover}/smt/solver/ctx-simplify.ts +0 -0
  252. /package/src/{prove → prover}/smt/solver/der.ts +0 -0
  253. /package/src/{prove → prover}/smt/solver/dyn-ack.ts +0 -0
  254. /package/src/{prove → prover}/smt/solver/e-matching.ts +0 -0
  255. /package/src/{prove → prover}/smt/solver/expr-ref.ts +0 -0
  256. /package/src/{prove → prover}/smt/solver/expr-safe-replace.ts +0 -0
  257. /package/src/{prove → prover}/smt/solver/fingerprints.ts +0 -0
  258. /package/src/{prove → prover}/smt/solver/flat-literals.ts +0 -0
  259. /package/src/{prove → prover}/smt/solver/goal.ts +0 -0
  260. /package/src/{prove → prover}/smt/solver/hash.ts +0 -0
  261. /package/src/{prove → prover}/smt/solver/hashtable.ts +0 -0
  262. /package/src/{prove → prover}/smt/solver/internalizer.ts +0 -0
  263. /package/src/{prove → prover}/smt/solver/lbool.ts +0 -0
  264. /package/src/{prove → prover}/smt/solver/literal.ts +0 -0
  265. /package/src/{prove → prover}/smt/solver/lp/bound-propagator.ts +0 -0
  266. /package/src/{prove → prover}/smt/solver/lp/constraints.ts +0 -0
  267. /package/src/{prove → prover}/smt/solver/lp/containers.ts +0 -0
  268. /package/src/{prove → prover}/smt/solver/lp/core-solver.ts +0 -0
  269. /package/src/{prove → prover}/smt/solver/lp/cross-nested.ts +0 -0
  270. /package/src/{prove → prover}/smt/solver/lp/dependency.ts +0 -0
  271. /package/src/{prove → prover}/smt/solver/lp/dioph-eq.ts +0 -0
  272. /package/src/{prove → prover}/smt/solver/lp/explanation.ts +0 -0
  273. /package/src/{prove → prover}/smt/solver/lp/gomory.ts +0 -0
  274. /package/src/{prove → prover}/smt/solver/lp/hnf-cutter.ts +0 -0
  275. /package/src/{prove → prover}/smt/solver/lp/hnf.ts +0 -0
  276. /package/src/{prove → prover}/smt/solver/lp/int-cube.ts +0 -0
  277. /package/src/{prove → prover}/smt/solver/lp/int-solver.ts +0 -0
  278. /package/src/{prove → prover}/smt/solver/lp/lar-solver.ts +0 -0
  279. /package/src/{prove → prover}/smt/solver/lp/lar-term.ts +0 -0
  280. /package/src/{prove → prover}/smt/solver/lp/lp-settings.ts +0 -0
  281. /package/src/{prove → prover}/smt/solver/lp/maximize-term.ts +0 -0
  282. /package/src/{prove → prover}/smt/solver/lp/nex-creator.ts +0 -0
  283. /package/src/{prove → prover}/smt/solver/lp/nex.ts +0 -0
  284. /package/src/{prove → prover}/smt/solver/lp/nla-backoff.ts +0 -0
  285. /package/src/{prove → prover}/smt/solver/lp/nla-basics.ts +0 -0
  286. /package/src/{prove → prover}/smt/solver/lp/nla-core.ts +0 -0
  287. /package/src/{prove → prover}/smt/solver/lp/nla-divisions.ts +0 -0
  288. /package/src/{prove → prover}/smt/solver/lp/nla-emonics.ts +0 -0
  289. /package/src/{prove → prover}/smt/solver/lp/nla-factorization.ts +0 -0
  290. /package/src/{prove → prover}/smt/solver/lp/nla-grobner.ts +0 -0
  291. /package/src/{prove → prover}/smt/solver/lp/nla-horner.ts +0 -0
  292. /package/src/{prove → prover}/smt/solver/lp/nla-intervals.ts +0 -0
  293. /package/src/{prove → prover}/smt/solver/lp/nla-monomial-bounds.ts +0 -0
  294. /package/src/{prove → prover}/smt/solver/lp/nla-monotone.ts +0 -0
  295. /package/src/{prove → prover}/smt/solver/lp/nla-order.ts +0 -0
  296. /package/src/{prove → prover}/smt/solver/lp/nla-patcher.ts +0 -0
  297. /package/src/{prove → prover}/smt/solver/lp/nla-tangents.ts +0 -0
  298. /package/src/{prove → prover}/smt/solver/lp/nla-throttle.ts +0 -0
  299. /package/src/{prove → prover}/smt/solver/lp/nla-types.ts +0 -0
  300. /package/src/{prove → prover}/smt/solver/lp/nla-var-eqs.ts +0 -0
  301. /package/src/{prove → prover}/smt/solver/lp/nra-solver.ts +0 -0
  302. /package/src/{prove → prover}/smt/solver/lp/numeric-pair.ts +0 -0
  303. /package/src/{prove → prover}/smt/solver/lp/pdd-interval.ts +0 -0
  304. /package/src/{prove → prover}/smt/solver/lp/pdd-simplifier.ts +0 -0
  305. /package/src/{prove → prover}/smt/solver/lp/pdd-solver.ts +0 -0
  306. /package/src/{prove → prover}/smt/solver/lp/pdd.ts +0 -0
  307. /package/src/{prove → prover}/smt/solver/lp/random-updater.ts +0 -0
  308. /package/src/{prove → prover}/smt/solver/lp/static-matrix.ts +0 -0
  309. /package/src/{prove → prover}/smt/solver/lp/union-find.ts +0 -0
  310. /package/src/{prove → prover}/smt/solver/mam-compiler.ts +0 -0
  311. /package/src/{prove → prover}/smt/solver/mam-interpreter.ts +0 -0
  312. /package/src/{prove → prover}/smt/solver/maximize-ac-sharing.ts +0 -0
  313. /package/src/{prove → prover}/smt/solver/model-checker.ts +0 -0
  314. /package/src/{prove → prover}/smt/solver/model-evaluator.ts +0 -0
  315. /package/src/{prove → prover}/smt/solver/model-finder.ts +0 -0
  316. /package/src/{prove → prover}/smt/solver/model-generator.ts +0 -0
  317. /package/src/{prove → prover}/smt/solver/nlsat/evaluator.ts +0 -0
  318. /package/src/{prove → prover}/smt/solver/nlsat/mpbq.ts +0 -0
  319. /package/src/{prove → prover}/smt/solver/nlsat/solver.ts +0 -0
  320. /package/src/{prove → prover}/smt/solver/nlsat/types.ts +0 -0
  321. /package/src/{prove → prover}/smt/solver/nlsat/upolynomial-factorization.ts +0 -0
  322. /package/src/{prove → prover}/smt/solver/nnf.ts +0 -0
  323. /package/src/{prove → prover}/smt/solver/poly-rewriter.ts +0 -0
  324. /package/src/{prove → prover}/smt/solver/propagate-values.ts +0 -0
  325. /package/src/{prove → prover}/smt/solver/proto-model.ts +0 -0
  326. /package/src/{prove → prover}/smt/solver/pull-quant.ts +0 -0
  327. /package/src/{prove → prover}/smt/solver/qe-lite-der.ts +0 -0
  328. /package/src/{prove → prover}/smt/solver/qe-lite-fm.ts +0 -0
  329. /package/src/{prove → prover}/smt/solver/qe-lite.ts +0 -0
  330. /package/src/{prove → prover}/smt/solver/qi-queue.ts +0 -0
  331. /package/src/{prove → prover}/smt/solver/quant-tactics.ts +0 -0
  332. /package/src/{prove → prover}/smt/solver/quantifier-analyzer.ts +0 -0
  333. /package/src/{prove → prover}/smt/solver/quantifier-manager.ts +0 -0
  334. /package/src/{prove → prover}/smt/solver/random-gen.ts +0 -0
  335. /package/src/{prove → prover}/smt/solver/rational.ts +0 -0
  336. /package/src/{prove → prover}/smt/solver/ref-vector.ts +0 -0
  337. /package/src/{prove → prover}/smt/solver/rewriter-tpl.ts +0 -0
  338. /package/src/{prove → prover}/smt/solver/rlimit.ts +0 -0
  339. /package/src/{prove → prover}/smt/solver/smtlib-parser.ts +0 -0
  340. /package/src/{prove → prover}/smt/solver/sort.ts +0 -0
  341. /package/src/{prove → prover}/smt/solver/sticky-generations.ts +0 -0
  342. /package/src/{prove → prover}/smt/solver/theory-lra-axioms.ts +0 -0
  343. /package/src/{prove → prover}/smt/solver/theory-lra-bounds.ts +0 -0
  344. /package/src/{prove → prover}/smt/solver/theory-lra-final-check.ts +0 -0
  345. /package/src/{prove → prover}/smt/solver/theory-lra-internalize.ts +0 -0
  346. /package/src/{prove → prover}/smt/solver/theory-lra-model.ts +0 -0
  347. /package/src/{prove → prover}/smt/solver/theory-lra-propagate.ts +0 -0
  348. /package/src/{prove → prover}/smt/solver/theory-lra-state.ts +0 -0
  349. /package/src/{prove → prover}/smt/solver/theory-lra.ts +0 -0
  350. /package/src/{prove → prover}/smt/solver/var-subst.ts +0 -0
  351. /package/src/{prove → prover}/smt/solver/z3-license.txt +0 -0
  352. /package/src/{prove → prover}/smt/table.ts +0 -0
  353. /package/src/{prove → prover}/tlaps-module.ts +0 -0
  354. /package/src/{prove → prover}/zenon/LICENSE +0 -0
  355. /package/src/{prove → prover}/zenon/check/check.ts +0 -0
  356. /package/src/{prove → prover}/zenon/check/definitions.ts +0 -0
  357. /package/src/{prove → prover}/zenon/check/equality.ts +0 -0
  358. /package/src/{prove → prover}/zenon/check/functions.ts +0 -0
  359. /package/src/{prove → prover}/zenon/check/keys.ts +0 -0
  360. /package/src/{prove → prover}/zenon/check/propositional.ts +0 -0
  361. /package/src/{prove → prover}/zenon/check/records.ts +0 -0
  362. /package/src/{prove → prover}/zenon/check/relations.ts +0 -0
  363. /package/src/{prove → prover}/zenon/check/rewrites.ts +0 -0
  364. /package/src/{prove → prover}/zenon/check/sets.ts +0 -0
  365. /package/src/{prove → prover}/zenon/check/terms.ts +0 -0
  366. /package/src/{prove → prover}/zenon/check/tla.ts +0 -0
  367. /package/src/{prove → prover}/zenon/isar-case.ts +0 -0
  368. /package/src/{prove → prover}/zenon/limits.ts +0 -0
  369. /package/src/{prove → prover}/zenon/ocaml.ts +0 -0
  370. /package/src/{prove → prover}/zenon/parse.ts +0 -0
  371. /package/src/{prove → prover}/zenon/phrase.ts +0 -0
  372. /package/src/{prove → prover}/zenon/proof.ts +0 -0
  373. /package/src/{prove → prover}/zenon/propositional-rules.ts +0 -0
  374. /package/src/{prove → prover}/zenon/rules.ts +0 -0
  375. /package/src/{prove → prover}/zenon/tla/functions.ts +0 -0
  376. /package/src/{prove → prover}/zenon/tla/llproof.ts +0 -0
  377. /package/src/{prove → prover}/zenon/tla/records.ts +0 -0
  378. /package/src/{prove → prover}/zenon/tla/rewrites.ts +0 -0
  379. /package/src/{prove → prover}/zenon/tla/sets.ts +0 -0
  380. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  381. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
  382. /package/src/{tlc-version.ts → tlc/version.ts} +0 -0
@@ -49,7 +49,7 @@ export interface LivenessChecker {
49
49
  getViolatedProperties: (path: Value[][], cycleStart: number) => string[];
50
50
  }
51
51
 
52
- export interface LiveGraph {
52
+ interface SearchGraph {
53
53
  getFingerprint: (successor: LiveSuccessor) => number;
54
54
  getSuccessors: (index: number, state: Value[]) => LiveSuccessor[];
55
55
  }
@@ -63,7 +63,7 @@ interface Pool<Data extends Int32Array | Uint8Array> {
63
63
  }
64
64
 
65
65
  // TLC's behavior graph for one solution: a node per state, or per state and tableau node.
66
- interface Check {
66
+ interface BehaviorGraph {
67
67
  solution: Solution;
68
68
  // One id per distinct action check across the solutions.
69
69
  actionIds: Int32Array;
@@ -79,7 +79,7 @@ interface Check {
79
79
  edgeActions: Pool<Uint8Array>;
80
80
  stateResults: Pool<Uint8Array>;
81
81
  initial: number[];
82
- // The nodes of each state in the order the check records them, a list through nextSiblings.
82
+ // The nodes of each state in the order they are recorded, a list through nextSiblings.
83
83
  firstNodes: Pool<Int32Array>;
84
84
  lastNodes: Pool<Int32Array>;
85
85
  nextSiblings: number[];
@@ -165,35 +165,35 @@ const createNodes = (length: number) => new Int32Array(length).fill(NO_NODE);
165
165
 
166
166
  const UNWRITTEN = -1;
167
167
 
168
- const isWritten = (check: Check, node: number) =>
169
- (check.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
168
+ const isWritten = (behavior: BehaviorGraph, node: number) =>
169
+ (behavior.edgeStarts[node] ?? UNWRITTEN) !== UNWRITTEN;
170
170
 
171
- const getSuccessors = (check: Check, node: number) => {
172
- const start = check.edgeStarts[node];
173
- return check.edgeTargets.data.subarray(start, start + check.edgeCounts[node]);
171
+ const getNodeSuccessors = (behavior: BehaviorGraph, node: number) => {
172
+ const start = behavior.edgeStarts[node];
173
+ return behavior.edgeTargets.data.subarray(start, start + behavior.edgeCounts[node]);
174
174
  };
175
175
 
176
- const getStateResult = (check: Check, node: number, position: number) =>
177
- check.stateResults.data[check.nodeStates[node] * check.solution.stateChecks.length + position] ===
178
- 1;
179
-
180
- // A node owns one entry in each of its check's per-node arrays.
181
- const pushNode = (check: Check, state: number, tableauNode: number) => {
182
- check.nodeStates.push(state);
183
- check.nodeTableaux.push(tableauNode);
184
- check.edgeStarts.push(UNWRITTEN);
185
- check.edgeCounts.push(0);
186
- check.nextSiblings.push(NO_NODE);
187
- return check.nodeStates.length - 1;
176
+ const getStateResult = (behavior: BehaviorGraph, node: number, position: number) =>
177
+ behavior.stateResults.data[
178
+ behavior.nodeStates[node] * behavior.solution.stateChecks.length + position
179
+ ] === 1;
180
+
181
+ // A node owns one entry in each per-node array of its graph.
182
+ const pushNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
183
+ behavior.nodeStates.push(state);
184
+ behavior.nodeTableaux.push(tableauNode);
185
+ behavior.edgeStarts.push(UNWRITTEN);
186
+ behavior.edgeCounts.push(0);
187
+ behavior.nextSiblings.push(NO_NODE);
188
+ return behavior.nodeStates.length - 1;
188
189
  };
189
190
 
190
- // The nodes of the state, in the order the check recorded them.
191
- const getStateNodes = (check: Check, state: number) => {
191
+ const getStateNodes = (behavior: BehaviorGraph, state: number) => {
192
192
  const nodes: number[] = [];
193
193
  for (
194
- let node = check.firstNodes.data[state] ?? NO_NODE;
194
+ let node = behavior.firstNodes.data[state] ?? NO_NODE;
195
195
  node !== NO_NODE;
196
- node = check.nextSiblings[node]
196
+ node = behavior.nextSiblings[node]
197
197
  ) {
198
198
  nodes.push(node);
199
199
  }
@@ -212,7 +212,7 @@ export const createLivenessChecker = (
212
212
  properties: TemporalProperty[],
213
213
  temporals: ScopedExpression[],
214
214
  environment: Environment,
215
- graph: LiveGraph,
215
+ search: SearchGraph,
216
216
  ): LivenessChecker | undefined => {
217
217
  if (properties.length === 0) return undefined;
218
218
  const fairness = temporals.map((item) =>
@@ -229,7 +229,7 @@ export const createLivenessChecker = (
229
229
  throw createTautologyError();
230
230
  }
231
231
  const actionIds = new Map<string, number>();
232
- const checks = solutions.map((solution): Check => ({
232
+ const behaviors = solutions.map((solution): BehaviorGraph => ({
233
233
  solution,
234
234
  actionIds: Int32Array.from(solution.actionChecks, (predicate) => {
235
235
  const key = getTermKey(predicate);
@@ -282,15 +282,20 @@ export const createLivenessChecker = (
282
282
  evaluation.environment,
283
283
  isShared ? getStateCache(state) : new Map(),
284
284
  );
285
- const checkState = (check: Check, source: number, state: Value[]) =>
285
+ const checkState = (behavior: BehaviorGraph, source: number, state: Value[]) =>
286
286
  evaluateFrom(source, () =>
287
- Uint8Array.from(check.solution.stateChecks, (predicate) =>
287
+ Uint8Array.from(behavior.solution.stateChecks, (predicate) =>
288
288
  evaluateState(predicate, state) ? 1 : 0,
289
289
  ),
290
290
  );
291
- const checkAction = (check: Check, source: number, state: Value[], successor: Value[]) =>
291
+ const checkAction = (
292
+ behavior: BehaviorGraph,
293
+ source: number,
294
+ state: Value[],
295
+ successor: Value[],
296
+ ) =>
292
297
  evaluateFrom(source, () => {
293
- const predicates = check.solution.actionChecks;
298
+ const predicates = behavior.solution.actionChecks;
294
299
  if (!isShared) {
295
300
  return Uint8Array.from(predicates, (predicate) =>
296
301
  evaluateLive(predicate, state, successor, evaluation.environment, new Map()) ? 1 : 0,
@@ -301,7 +306,7 @@ export const createLivenessChecker = (
301
306
  shared.actions.set(state, results);
302
307
  const known = results.get(successor) ?? new Int8Array(actionIds.size).fill(-1);
303
308
  results.set(successor, known);
304
- return Uint8Array.from(check.actionIds, (id, position) => {
309
+ return Uint8Array.from(behavior.actionIds, (id, position) => {
305
310
  if (known[id] === -1) {
306
311
  known[id] = evaluateLive(
307
312
  predicates[position],
@@ -336,23 +341,23 @@ export const createLivenessChecker = (
336
341
  tableauNode.successors[0] === node
337
342
  );
338
343
  };
339
- const hasEmptyModel = (check: Check) =>
340
- check.solution.models.some(
344
+ const hasEmptyModel = (behavior: BehaviorGraph) =>
345
+ behavior.solution.models.some(
341
346
  (model) =>
342
347
  model.eventuallyAlways.length === 0 &&
343
348
  model.infinitelyOftenStates.length === 0 &&
344
349
  model.infinitelyOftenActions.length === 0,
345
350
  );
346
351
 
347
- const getNodeId = (check: Check, state: number, tableauNode: number) => {
348
- if (!check.solution.tableau) return state;
349
- const slots = check.nodeIds.slots;
350
- const slot = getNodeSlot(check.nodeIds, state, tableauNode);
352
+ const getNodeId = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
353
+ if (!behavior.solution.tableau) return state;
354
+ const slots = behavior.nodeIds.slots;
355
+ const slot = getNodeSlot(behavior.nodeIds, state, tableauNode);
351
356
  return slots[slot] === 0 ? undefined : slots[slot + 2];
352
357
  };
353
- const recordNode = (check: Check, state: number, tableauNode: number) => {
354
- const node = pushNode(check, state, tableauNode);
355
- const table = check.nodeIds;
358
+ const recordNode = (behavior: BehaviorGraph, state: number, tableauNode: number) => {
359
+ const node = pushNode(behavior, state, tableauNode);
360
+ const table = behavior.nodeIds;
356
361
  if (++table.size * 2 > table.slots.length / 3) {
357
362
  const old = table.slots;
358
363
  table.slots = new Int32Array(old.length * 2);
@@ -367,28 +372,32 @@ export const createLivenessChecker = (
367
372
  }
368
373
  }
369
374
  table.slots.set([state + 1, tableauNode, node], getNodeSlot(table, state, tableauNode));
370
- const last = check.lastNodes.data[state] ?? NO_NODE;
371
- if (last === NO_NODE) writeToPool(check.firstNodes, state, [node]);
372
- else check.nextSiblings[last] = node;
373
- writeToPool(check.lastNodes, state, [node]);
375
+ const last = behavior.lastNodes.data[state] ?? NO_NODE;
376
+ if (last === NO_NODE) writeToPool(behavior.firstNodes, state, [node]);
377
+ else behavior.nextSiblings[last] = node;
378
+ writeToPool(behavior.lastNodes, state, [node]);
374
379
  return node;
375
380
  };
376
381
  const writeNode = (
377
- check: Check,
382
+ behavior: BehaviorGraph,
378
383
  node: number,
379
384
  targets: number[],
380
385
  actions: Uint8Array[],
381
386
  stateResults: Uint8Array,
382
387
  ) => {
383
- const start = check.edgeTargets.length;
384
- const actionCount = check.solution.actionChecks.length;
385
- writeToPool(check.edgeTargets, start, targets);
388
+ const start = behavior.edgeTargets.length;
389
+ const actionCount = behavior.solution.actionChecks.length;
390
+ writeToPool(behavior.edgeTargets, start, targets);
386
391
  actions.forEach((results, position) =>
387
- writeToPool(check.edgeActions, (start + position) * actionCount, results),
392
+ writeToPool(behavior.edgeActions, (start + position) * actionCount, results),
393
+ );
394
+ writeToPool(
395
+ behavior.stateResults,
396
+ behavior.nodeStates[node] * stateResults.length,
397
+ stateResults,
388
398
  );
389
- writeToPool(check.stateResults, check.nodeStates[node] * stateResults.length, stateResults);
390
- check.edgeStarts[node] = start;
391
- check.edgeCounts[node] = targets.length;
399
+ behavior.edgeStarts[node] = start;
400
+ behavior.edgeCounts[node] = targets.length;
392
401
  };
393
402
 
394
403
  // TLC collects a state's successors and the state itself in a SetOfStates, a hash set it
@@ -401,9 +410,9 @@ export const createLivenessChecker = (
401
410
  }),
402
411
  count: 0,
403
412
  };
404
- const insert = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
413
+ const insertSuccessor = (slots: (LiveSuccessor | undefined)[], successor: LiveSuccessor) => {
405
414
  for (
406
- let slot = (graph.getFingerprint(successor) & 0x7fffffff) % slots.length;
415
+ let slot = (search.getFingerprint(successor) & 0x7fffffff) % slots.length;
407
416
  ;
408
417
  slot = (slot + 1) % slots.length
409
418
  ) {
@@ -416,72 +425,76 @@ export const createLivenessChecker = (
416
425
  return false;
417
426
  }
418
427
  };
419
- const put = (successor: LiveSuccessor) => {
428
+ const addSuccessor = (successor: LiveSuccessor) => {
420
429
  if (table.count >= table.slots.length >> 1) {
421
430
  const old = table.slots;
422
431
  table.slots = Array.from<LiveSuccessor | undefined>({ length: 2 * old.length + 1 });
423
- for (const entry of old) if (entry) insert(table.slots, entry);
432
+ for (const entry of old) if (entry) insertSuccessor(table.slots, entry);
424
433
  }
425
- if (insert(table.slots, successor)) table.count++;
434
+ if (insertSuccessor(table.slots, successor)) table.count++;
426
435
  };
427
- successors.forEach(put);
428
- put({ index, state });
436
+ successors.forEach(addSuccessor);
437
+ addSuccessor({ index, state });
429
438
  if (table.slots.length > SUCCESSOR_CAPACITY * capacity.multiplier) capacity.multiplier++;
430
439
  return table.slots.filter((entry): entry is LiveSuccessor => entry !== undefined);
431
440
  };
432
441
 
433
442
  // TLC's TableauLiveChecker#addNextState for a node it finds after it expanded the node's state.
434
443
  const expandLate = (
435
- check: Check,
444
+ behavior: BehaviorGraph,
436
445
  tableau: Tableau,
437
446
  state: Value[],
438
447
  index: number,
439
448
  node: number,
440
449
  ) => {
441
- const stateResults = checkState(check, index, state);
442
- const tableauNode = tableau.nodes[check.nodeTableaux[node]];
450
+ const stateResults = checkState(behavior, index, state);
451
+ const tableauNode = tableau.nodes[behavior.nodeTableaux[node]];
443
452
  const actions: Uint8Array[] = [];
444
453
  const successors: number[] = [];
445
454
  const selfActions =
446
455
  tableauNode.successors.length > 0
447
- ? checkAction(check, index, state, state)
456
+ ? checkAction(behavior, index, state, state)
448
457
  : new Uint8Array(0);
449
458
  for (const next of tableauNode.successors) {
450
459
  if (!isConsistent(tableau, next, index, state)) continue;
451
- if (isAccepting(tableau, next) && check.errorNode === undefined && hasEmptyModel(check)) {
452
- check.errorNode = node;
460
+ if (
461
+ isAccepting(tableau, next) &&
462
+ behavior.errorNode === undefined &&
463
+ hasEmptyModel(behavior)
464
+ ) {
465
+ behavior.errorNode = node;
453
466
  return;
454
467
  }
455
- const existing = getNodeId(check, index, next);
468
+ const existing = getNodeId(behavior, index, next);
456
469
  if (existing !== undefined && successors.includes(existing)) continue;
457
- const target = existing ?? recordNode(check, index, next);
470
+ const target = existing ?? recordNode(behavior, index, next);
458
471
  successors.push(target);
459
472
  actions.push(selfActions);
460
- if (existing === undefined) expandLate(check, tableau, state, index, target);
473
+ if (existing === undefined) expandLate(behavior, tableau, state, index, target);
461
474
  }
462
- for (const successor of graph.getSuccessors(index, state)) {
463
- const successorActions = checkAction(check, index, state, successor.state);
464
- const isDone = check.isDone[successor.index] === true;
475
+ for (const successor of search.getSuccessors(index, state)) {
476
+ const successorActions = checkAction(behavior, index, state, successor.state);
477
+ const isDone = behavior.isDone[successor.index] === true;
465
478
  for (const next of tableauNode.successors) {
466
479
  if (!isConsistent(tableau, next, index, successor.state)) continue;
467
480
  // A successor the search never stored follows a violation or an error, after which nothing
468
481
  // checks the graph. TLC records its node, which it never expands.
469
482
  if (successor.index === -1) continue;
470
- const existing = getNodeId(check, successor.index, next);
483
+ const existing = getNodeId(behavior, successor.index, next);
471
484
  if (existing !== undefined && successors.includes(existing)) continue;
472
- const target = existing ?? recordNode(check, successor.index, next);
485
+ const target = existing ?? recordNode(behavior, successor.index, next);
473
486
  successors.push(target);
474
487
  actions.push(successorActions);
475
488
  if (existing === undefined && isDone) {
476
- expandLate(check, tableau, successor.state, successor.index, target);
489
+ expandLate(behavior, tableau, successor.state, successor.index, target);
477
490
  }
478
491
  }
479
492
  }
480
- if (successors.length > 0) writeNode(check, node, successors, actions, stateResults);
493
+ if (successors.length > 0) writeNode(behavior, node, successors, actions, stateResults);
481
494
  };
482
495
 
483
496
  const addTableauState = (
484
- check: Check,
497
+ behavior: BehaviorGraph,
485
498
  tableau: Tableau,
486
499
  set: LiveSuccessor[],
487
500
  actionResults: Uint8Array[],
@@ -491,74 +504,73 @@ export const createLivenessChecker = (
491
504
  const consistency = tableau.nodes.map((_, node) =>
492
505
  set.map((successor) => isConsistent(tableau, node, index, successor.state)),
493
506
  );
494
- check.isDone[index] = true;
507
+ behavior.isDone[index] = true;
495
508
  // TLC expands the nodes recorded before the loop, not the ones the loop records.
496
- for (const node of getStateNodes(check, index)) {
509
+ for (const node of getStateNodes(behavior, index)) {
497
510
  const successors: number[] = [];
498
511
  const actions: Uint8Array[] = [];
499
512
  set.forEach((successor, position) => {
500
- const isDone = check.isDone[successor.index] === true;
501
- for (const next of tableau.nodes[check.nodeTableaux[node]].successors) {
513
+ const isDone = behavior.isDone[successor.index] === true;
514
+ for (const next of tableau.nodes[behavior.nodeTableaux[node]].successors) {
502
515
  if (!consistency[next][position]) continue;
503
- const existing = getNodeId(check, successor.index, next);
516
+ const existing = getNodeId(behavior, successor.index, next);
504
517
  if (existing !== undefined && successors.includes(existing)) continue;
505
- const target = existing ?? recordNode(check, successor.index, next);
518
+ const target = existing ?? recordNode(behavior, successor.index, next);
506
519
  successors.push(target);
507
520
  actions.push(actionResults[position]);
508
521
  if (existing === undefined && isDone) {
509
- expandLate(check, tableau, successor.state, successor.index, target);
522
+ expandLate(behavior, tableau, successor.state, successor.index, target);
510
523
  }
511
524
  }
512
525
  });
513
- writeNode(check, node, successors, actions, stateResults);
526
+ writeNode(behavior, node, successors, actions, stateResults);
514
527
  }
515
- if (check.errorNode === undefined) return undefined;
528
+ if (behavior.errorNode === undefined) return undefined;
516
529
  return removeRepeats(
517
- getPath(check, check.errorNode)
530
+ getPath(behavior, behavior.errorNode)
518
531
  .reverse()
519
- .map((node) => check.nodeStates[node]),
532
+ .map((node) => behavior.nodeStates[node]),
520
533
  );
521
534
  };
522
535
 
523
536
  const addPlainState = (
524
- check: Check,
537
+ behavior: BehaviorGraph,
525
538
  set: LiveSuccessor[],
526
539
  actionResults: Uint8Array[],
527
540
  stateResults: Uint8Array,
528
541
  index: number,
529
542
  ) => {
530
- while (check.nodeStates.length <= index) pushNode(check, check.nodeStates.length, -1);
543
+ while (behavior.nodeStates.length <= index) pushNode(behavior, behavior.nodeStates.length, -1);
531
544
  const successors: number[] = [];
532
545
  const actions: Uint8Array[] = [];
533
546
  set.forEach((successor, position) => {
534
- if (isWritten(check, successor.index) && successors.includes(successor.index)) return;
547
+ if (isWritten(behavior, successor.index) && successors.includes(successor.index)) return;
535
548
  successors.push(successor.index);
536
549
  actions.push(actionResults[position]);
537
550
  });
538
- writeNode(check, index, successors, actions, stateResults);
539
- return undefined;
551
+ writeNode(behavior, index, successors, actions, stateResults);
540
552
  };
541
553
 
542
554
  // The shortest path from an initial node to the node, last node first, as TLC's getPath finds it.
543
- const getPath = (check: Check, target: number) => {
544
- if (check.initial.includes(target)) return [target];
555
+ const getPath = (behavior: BehaviorGraph, target: number) => {
556
+ if (behavior.initial.includes(target)) return [target];
545
557
  const parents = new Map<number, number>();
546
558
  const queue: number[] = [];
547
- for (const node of check.initial) {
548
- if (!isWritten(check, node)) continue;
559
+ for (const node of behavior.initial) {
560
+ if (!isWritten(behavior, node)) continue;
549
561
  queue.push(node);
550
562
  parents.set(node, -1);
551
563
  }
552
564
  for (let position = 0; position < queue.length; position++) {
553
565
  const current = queue[position];
554
- for (const next of getSuccessors(check, current)) {
555
- if (next === current && check.solution.tableau) continue;
566
+ for (const next of getNodeSuccessors(behavior, current)) {
567
+ if (next === current && behavior.solution.tableau) continue;
556
568
  if (next === target) {
557
569
  const path = [target];
558
570
  for (let node = current; node !== -1; node = parents.get(node) ?? -1) path.push(node);
559
571
  return path;
560
572
  }
561
- if (!isWritten(check, next) || parents.has(next)) continue;
573
+ if (!isWritten(behavior, next) || parents.has(next)) continue;
562
574
  parents.set(next, current);
563
575
  queue.push(next);
564
576
  }
@@ -567,24 +579,27 @@ export const createLivenessChecker = (
567
579
  };
568
580
 
569
581
  // TLC's LiveWorker#checkSccs, a Tarjan search that pushes every successor of a node at once.
570
- const findInModel = (check: Check, model: Solution["models"][number]): Lasso | undefined => {
571
- const solution = check.solution;
582
+ const findLassoInModel = (
583
+ behavior: BehaviorGraph,
584
+ model: Solution["models"][number],
585
+ ): Lasso | undefined => {
586
+ const solution = behavior.solution;
572
587
  const actionCount = solution.actionChecks.length;
573
588
  const getAction = (node: number, edge: number, position: number) =>
574
- check.edgeActions.data[(check.edgeStarts[node] + edge) * actionCount + position] === 1;
589
+ behavior.edgeActions.data[(behavior.edgeStarts[node] + edge) * actionCount + position] === 1;
575
590
  const isAllowed = (node: number, edge: number) =>
576
591
  model.eventuallyAlways.every((position) => getAction(node, edge, position));
577
- const links = new Float64Array(check.nodeStates.length).fill(UNVISITED);
578
- const queue = check.initial.filter((node) => isWritten(check, node));
592
+ const links = new Float64Array(behavior.nodeStates.length).fill(UNVISITED);
593
+ const queue = behavior.initial.filter((node) => isWritten(behavior, node));
579
594
  const components: number[] = [];
580
595
 
581
596
  const isStuttering = (node: number) => {
582
- const edge = getSuccessors(check, node).indexOf(node);
597
+ const edge = getNodeSuccessors(behavior, node).indexOf(node);
583
598
  return edge !== -1 && isAllowed(node, edge);
584
599
  };
585
600
  const isFulfilled = (node: number, promise: Solution["promises"][number]) =>
586
601
  solution.tableau !== undefined &&
587
- isFulfilling(solution.tableau.nodes[check.nodeTableaux[node]].particle, promise);
602
+ isFulfilling(solution.tableau.nodes[behavior.nodeTableaux[node]].particle, promise);
588
603
 
589
604
  const checkComponent = (root: number) => {
590
605
  const top = components.pop() ?? root;
@@ -596,18 +611,18 @@ export const createLivenessChecker = (
596
611
  const membersByState = new Map<number, number[]>();
597
612
  for (let member = top; ; member = components.pop() ?? root) {
598
613
  members.add(member);
599
- const siblings = membersByState.get(check.nodeStates[member]);
614
+ const siblings = membersByState.get(behavior.nodeStates[member]);
600
615
  if (siblings) siblings.push(member);
601
- else membersByState.set(check.nodeStates[member], [member]);
616
+ else membersByState.set(behavior.nodeStates[member], [member]);
602
617
  links[member] = MAXIMUM_LINK;
603
618
  if (member === root) break;
604
619
  }
605
620
  const isStateSatisfied = model.infinitelyOftenStates.every((position) =>
606
- [...members].some((node) => getStateResult(check, node, position)),
621
+ [...members].some((node) => getStateResult(behavior, node, position)),
607
622
  );
608
623
  const isActionSatisfied = model.infinitelyOftenActions.every((position) =>
609
624
  [...members].some((node) =>
610
- getSuccessors(check, node).some(
625
+ getNodeSuccessors(behavior, node).some(
611
626
  (next, edge) =>
612
627
  members.has(next) && isAllowed(node, edge) && getAction(node, edge, position),
613
628
  ),
@@ -628,9 +643,9 @@ export const createLivenessChecker = (
628
643
  membersByState: Map<number, number[]>,
629
644
  ) => {
630
645
  const prefix = removeRepeats(
631
- getPath(check, root)
646
+ getPath(behavior, root)
632
647
  .reverse()
633
- .map((node) => check.nodeStates[node]),
648
+ .map((node) => behavior.nodeStates[node]),
634
649
  );
635
650
  const cycleStack: number[] = [];
636
651
  const seen = new Set<number>([root]);
@@ -640,7 +655,7 @@ export const createLivenessChecker = (
640
655
  const remaining = { count: stateDone.length + actionDone.length + promiseDone.length };
641
656
  const current = { node: root };
642
657
  const isMember = (node: number) => members.has(node);
643
- const take = (next: number) => {
658
+ const moveTo = (next: number) => {
644
659
  cycleStack.push(current.node);
645
660
  current.node = next;
646
661
  };
@@ -648,7 +663,7 @@ export const createLivenessChecker = (
648
663
  const countAtStart = remaining.count;
649
664
  while (true) {
650
665
  model.infinitelyOftenStates.forEach((position, slot) => {
651
- if (!stateDone[slot] && getStateResult(check, current.node, position)) {
666
+ if (!stateDone[slot] && getStateResult(behavior, current.node, position)) {
652
667
  stateDone[slot] = true;
653
668
  remaining.count--;
654
669
  }
@@ -662,8 +677,8 @@ export const createLivenessChecker = (
662
677
  if (remaining.count <= 0) break;
663
678
  const step = { last: -1, unvisited: -1 };
664
679
  const countBeforeActions = remaining.count;
665
- const taken = getSuccessors(check, current.node).some((next, edge) => {
666
- if (membersByState.has(check.nodeStates[next])) {
680
+ const taken = getNodeSuccessors(behavior, current.node).some((next, edge) => {
681
+ if (membersByState.has(behavior.nodeStates[next])) {
667
682
  if (!isMember(next) || !isAllowed(current.node, edge)) return false;
668
683
  step.last = next;
669
684
  model.infinitelyOftenActions.forEach((position, slot) => {
@@ -674,7 +689,7 @@ export const createLivenessChecker = (
674
689
  });
675
690
  }
676
691
  if (remaining.count < countBeforeActions) {
677
- take(next);
692
+ moveTo(next);
678
693
  seen.clear();
679
694
  return true;
680
695
  }
@@ -683,7 +698,7 @@ export const createLivenessChecker = (
683
698
  });
684
699
  if (taken) break;
685
700
  if (remaining.count < countAtStart) {
686
- take(step.last);
701
+ moveTo(step.last);
687
702
  seen.clear();
688
703
  break;
689
704
  }
@@ -696,16 +711,17 @@ export const createLivenessChecker = (
696
711
  }
697
712
  current.node = previous;
698
713
  step.unvisited =
699
- getSuccessors(check, previous).find((next) => isMember(next) && !seen.has(next)) ??
700
- -1;
714
+ getNodeSuccessors(behavior, previous).find(
715
+ (next) => isMember(next) && !seen.has(next),
716
+ ) ?? -1;
701
717
  }
702
- take(step.unvisited);
718
+ moveTo(step.unvisited);
703
719
  seen.add(step.unvisited);
704
720
  }
705
721
  }
706
722
  const postfix = getClosingPath(root, current.node, membersByState, isAllowed);
707
723
  for (let position = cycleStack.length - 1; position >= 0; position--) {
708
- const state = check.nodeStates[cycleStack[position]];
724
+ const state = behavior.nodeStates[cycleStack[position]];
709
725
  if (postfix[postfix.length - 1] !== state) postfix.push(state);
710
726
  }
711
727
  const cycleState = prefix[prefix.length - 1];
@@ -725,13 +741,13 @@ export const createLivenessChecker = (
725
741
  isAllowedEdge: (node: number, edge: number) => boolean,
726
742
  ) => {
727
743
  if (end === root) return [];
728
- const start = check.nodeStates[end];
744
+ const start = behavior.nodeStates[end];
729
745
  const parents = new Map<number, number>();
730
746
  const seen = new Set<number>([start]);
731
747
  const queue: [number, number][] = [];
732
748
  for (let state = start, parent = -1, position = 0; ; position++) {
733
749
  for (const node of membersByState.get(state) ?? []) {
734
- for (const [edge, next] of getSuccessors(check, node).entries()) {
750
+ for (const [edge, next] of getNodeSuccessors(behavior, node).entries()) {
735
751
  if (next === node || !isAllowedEdge(node, edge)) continue;
736
752
  if (next === root) {
737
753
  const path: number[] = [];
@@ -743,7 +759,7 @@ export const createLivenessChecker = (
743
759
  path.push(start);
744
760
  return path;
745
761
  }
746
- const nextState = check.nodeStates[next];
762
+ const nextState = behavior.nodeStates[next];
747
763
  if (!membersByState.has(nextState) || seen.has(nextState)) continue;
748
764
  seen.add(nextState);
749
765
  queue.push([nextState, state]);
@@ -784,8 +800,8 @@ export const createLivenessChecker = (
784
800
  stack.push(lowLink, node, SCC_MARKER);
785
801
  components.push(node);
786
802
  const nextLowLink = { value: counter.link++ };
787
- getSuccessors(check, node).forEach((next, edge) => {
788
- if (!isWritten(check, next)) return;
803
+ getNodeSuccessors(behavior, node).forEach((next, edge) => {
804
+ if (!isWritten(behavior, next)) return;
789
805
  if (!isAllowed(node, edge)) {
790
806
  if (links[next] === UNVISITED) queue.push(next);
791
807
  return;
@@ -800,21 +816,23 @@ export const createLivenessChecker = (
800
816
  };
801
817
 
802
818
  return {
803
- branches: checks.length,
819
+ branches: behaviors.length,
804
820
  addInitialState: (index, state, tracing) => {
805
821
  evaluation.environment = tracing ?? environment;
806
822
  shared.states.clear();
807
823
  shared.actions.clear();
808
824
  try {
809
- for (const check of checks) {
810
- const tableau = check.solution.tableau;
825
+ for (const behavior of behaviors) {
826
+ const tableau = behavior.solution.tableau;
811
827
  if (!tableau) {
812
- check.initial.push(index);
828
+ behavior.initial.push(index);
813
829
  continue;
814
830
  }
815
831
  for (let node = 0; node < tableau.initialCount; node++) {
816
832
  if (!isConsistent(tableau, node, undefined, state)) continue;
817
- check.initial.push(getNodeId(check, index, node) ?? recordNode(check, index, node));
833
+ behavior.initial.push(
834
+ getNodeId(behavior, index, node) ?? recordNode(behavior, index, node),
835
+ );
818
836
  }
819
837
  }
820
838
  } finally {
@@ -827,15 +845,24 @@ export const createLivenessChecker = (
827
845
  shared.actions.clear();
828
846
  try {
829
847
  const set = getSuccessorSet(index, state, successors);
830
- for (const check of checks) {
848
+ for (const behavior of behaviors) {
831
849
  const actionResults = set.map((successor) =>
832
- checkAction(check, index, state, successor.state),
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(
859
+ behavior,
860
+ tableau,
861
+ set,
862
+ actionResults,
863
+ stateResults,
864
+ index,
833
865
  );
834
- const stateResults = checkState(check, index, state);
835
- const tableau = check.solution.tableau;
836
- const accepted = tableau
837
- ? addTableauState(check, tableau, set, actionResults, stateResults, index)
838
- : addPlainState(check, set, actionResults, stateResults, index);
839
866
  if (accepted) return accepted;
840
867
  }
841
868
  return undefined;
@@ -844,9 +871,9 @@ export const createLivenessChecker = (
844
871
  }
845
872
  },
846
873
  findViolation: () => {
847
- for (const check of checks) {
848
- for (const model of check.solution.models) {
849
- const lasso = findInModel(check, model);
874
+ for (const behavior of behaviors) {
875
+ for (const model of behavior.solution.models) {
876
+ const lasso = findLassoInModel(behavior, model);
850
877
  if (lasso) return lasso;
851
878
  }
852
879
  }