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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (587) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +6 -6
  3. package/dist/compile.js +10 -10
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +41 -37
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +21 -4
  8. package/dist/index.d.ts +21 -4
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +2681 -425
  15. package/dist/prove.js +2681 -425
  16. package/dist/run.cjs +41 -42
  17. package/dist/run.js +41 -42
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +97 -89
  21. package/dist/transfer.js +97 -89
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +1 -1
  25. package/src/ast.ts +72 -39
  26. package/src/bags.ts +50 -29
  27. package/src/builtins.ts +8 -16
  28. package/src/check-failure.ts +118 -0
  29. package/src/check-trace.ts +321 -0
  30. package/src/check.ts +828 -770
  31. package/src/cli/options.ts +6 -31
  32. package/src/cli/runtime-invariants.ts +20 -56
  33. package/src/cli/shared.ts +1 -1
  34. package/src/cli/tlapm.ts +433 -70
  35. package/src/cli/tlc-arguments.ts +224 -212
  36. package/src/cli/tlc-output.ts +701 -0
  37. package/src/cli/tlc-usage.ts +1 -2
  38. package/src/cli/tlc.ts +65 -712
  39. package/src/cli/xml-exporter.ts +23 -33
  40. package/src/codegen.ts +28 -20
  41. package/src/coverage.ts +255 -20
  42. package/src/dependencies.ts +96 -27
  43. package/src/dfid.ts +115 -50
  44. package/src/environment-config.ts +315 -0
  45. package/src/environment.ts +175 -373
  46. package/src/errors.ts +40 -5
  47. package/src/evaluate.ts +429 -139
  48. package/src/exit-codes.ts +28 -12
  49. package/src/fingerprints.ts +65 -1
  50. package/src/instances.ts +178 -17
  51. package/src/java-hash.ts +14 -0
  52. package/src/java-overrides.ts +2 -2
  53. package/src/json.ts +4 -7
  54. package/src/levels.ts +708 -272
  55. package/src/lexer.ts +17 -5
  56. package/src/liveness-checker.ts +707 -249
  57. package/src/liveness.ts +148 -95
  58. package/src/obligations/action.ts +14 -17
  59. package/src/obligations/anonymize.ts +37 -16
  60. package/src/obligations/enabled-axioms.ts +218 -0
  61. package/src/obligations/equality.ts +1 -3
  62. package/src/obligations/expression.ts +36 -8
  63. package/src/obligations/format.ts +0 -2
  64. package/src/obligations/generate.ts +66 -54
  65. package/src/obligations/index.ts +39 -9
  66. package/src/obligations/levels.ts +24 -11
  67. package/src/obligations/module.ts +28 -41
  68. package/src/obligations/normalize.ts +27 -18
  69. package/src/obligations/operators.ts +0 -2
  70. package/src/obligations/pragma.ts +53 -16
  71. package/src/obligations/printer.ts +48 -18
  72. package/src/obligations/proof.ts +3 -2
  73. package/src/obligations/regroup.ts +0 -2
  74. package/src/obligations/simplify.ts +55 -50
  75. package/src/obligations/source.ts +120 -74
  76. package/src/obligations/subexpression.ts +45 -18
  77. package/src/obligations/substitution.ts +1 -3
  78. package/src/obligations/temporal.ts +5 -7
  79. package/src/obligations/tuples.ts +0 -2
  80. package/src/parallel-worker.ts +17 -31
  81. package/src/parallel.ts +29 -47
  82. package/src/parser.ts +757 -326
  83. package/src/pretty-print.ts +1 -1
  84. package/src/prover/decide-pool.ts +3 -3
  85. package/src/prover/deciders.ts +12 -9
  86. package/src/prover/isabelle/decide.ts +3 -25
  87. package/src/prover/isabelle/encode.ts +72 -42
  88. package/src/prover/isabelle/isar/attrib.ts +250 -0
  89. package/src/prover/isabelle/isar/context.ts +335 -0
  90. package/src/prover/isabelle/isar/induct.ts +382 -0
  91. package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
  92. package/src/prover/isabelle/isar/method.ts +509 -212
  93. package/src/prover/isabelle/isar/proof.ts +570 -14
  94. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  95. package/src/prover/isabelle/isar/theory.ts +487 -76
  96. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  97. package/src/prover/isabelle/isar/type-check.ts +89 -14
  98. package/src/prover/isabelle/provers/blast/blast.ts +7 -65
  99. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  100. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  101. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  102. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  103. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  104. package/src/prover/isabelle/provers/clasimp.ts +1 -3
  105. package/src/prover/isabelle/provers/classical.ts +45 -20
  106. package/src/prover/isabelle/provers/hypsubst.ts +19 -30
  107. package/src/prover/isabelle/pure/bicompose.ts +9 -27
  108. package/src/prover/isabelle/pure/consts.ts +0 -2
  109. package/src/prover/isabelle/pure/conv.ts +2 -10
  110. package/src/prover/isabelle/pure/drule.ts +72 -6
  111. package/src/prover/isabelle/pure/envir.ts +0 -2
  112. package/src/prover/isabelle/pure/goal.ts +1 -3
  113. package/src/prover/isabelle/pure/logic.ts +1 -3
  114. package/src/prover/isabelle/pure/name.ts +0 -2
  115. package/src/prover/isabelle/pure/net.ts +0 -2
  116. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  117. package/src/prover/isabelle/pure/pattern.ts +0 -2
  118. package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
  119. package/src/prover/isabelle/pure/rewriter.ts +9 -20
  120. package/src/prover/isabelle/pure/search.ts +0 -2
  121. package/src/prover/isabelle/pure/seq.ts +0 -2
  122. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  123. package/src/prover/isabelle/pure/table.ts +2 -3
  124. package/src/prover/isabelle/pure/tactic.ts +0 -2
  125. package/src/prover/isabelle/pure/tactical.ts +42 -37
  126. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  127. package/src/prover/isabelle/pure/term.ts +3 -5
  128. package/src/prover/isabelle/pure/thm.ts +14 -13
  129. package/src/prover/isabelle/pure/type.ts +0 -2
  130. package/src/prover/isabelle/pure/unify.ts +0 -2
  131. package/src/prover/isabelle/pure/variable.ts +0 -2
  132. package/src/prover/isabelle/tla/classical-setup.ts +18 -16
  133. package/src/prover/isabelle/tla/context.ts +58 -11
  134. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  135. package/src/prover/isabelle/tla/logic.ts +49 -21
  136. package/src/prover/isabelle/tla/simpdata.ts +1 -12
  137. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  138. package/src/prover/ocaml.ts +4 -1
  139. package/src/prover/prep/action.ts +30 -31
  140. package/src/prover/prep/enabled-axioms.ts +11 -2
  141. package/src/prover/prep/fingerprint.ts +2 -5
  142. package/src/prover/prep/md5.ts +26 -29
  143. package/src/prover/prep/methods.ts +181 -51
  144. package/src/prover/prep/normalize.ts +38 -9
  145. package/src/prover/prove.ts +395 -94
  146. package/src/prover/ptl/decide.ts +95 -50
  147. package/src/prover/ptl/encode.ts +2 -3
  148. package/src/prover/ptl/tableau.ts +28 -2
  149. package/src/prover/smt/arithmetic.ts +310 -0
  150. package/src/prover/smt/axioms.ts +12 -8
  151. package/src/prover/smt/context.ts +43 -8
  152. package/src/prover/smt/data.ts +498 -379
  153. package/src/prover/smt/encode.ts +148 -57
  154. package/src/prover/smt/extensionality.ts +5 -3
  155. package/src/prover/smt/flatten.ts +4 -6
  156. package/src/prover/smt/format.ts +28 -4
  157. package/src/prover/smt/instances.ts +7 -1
  158. package/src/prover/smt/layout.ts +91 -0
  159. package/src/prover/smt/rewrite.ts +1016 -618
  160. package/src/prover/smt/simplify.ts +441 -0
  161. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -0
  162. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  163. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  164. package/src/prover/smt/solver/act-cache.ts +0 -1
  165. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  166. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  167. package/src/prover/smt/solver/aig.ts +889 -0
  168. package/src/prover/smt/solver/arith-rewriter.ts +624 -9
  169. package/src/prover/smt/solver/arith-terms.ts +121 -0
  170. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  171. package/src/prover/smt/solver/array-rewriter.ts +319 -0
  172. package/src/prover/smt/solver/asserted-formulas.ts +240 -56
  173. package/src/prover/smt/solver/ast-lt.ts +165 -11
  174. package/src/prover/smt/solver/ast-util.ts +160 -2
  175. package/src/prover/smt/solver/ast.ts +1483 -45
  176. package/src/prover/smt/solver/auf-solver.ts +25 -18
  177. package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
  178. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  179. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  180. package/src/prover/smt/solver/bound-manager.ts +196 -0
  181. package/src/prover/smt/solver/bound-simplifier.ts +598 -0
  182. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  183. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  184. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  185. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  186. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  187. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  188. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  189. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  190. package/src/prover/smt/solver/card2bv.ts +127 -0
  191. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  192. package/src/prover/smt/solver/cg-table.ts +39 -25
  193. package/src/prover/smt/solver/check-logic.ts +330 -0
  194. package/src/prover/smt/solver/clause.ts +0 -1
  195. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
  196. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  197. package/src/prover/smt/solver/context.ts +598 -128
  198. package/src/prover/smt/solver/ctx-simplify.ts +29 -14
  199. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  200. package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
  201. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  202. package/src/prover/smt/solver/demodulator.ts +786 -0
  203. package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
  204. package/src/prover/smt/solver/der.ts +38 -10
  205. package/src/prover/smt/solver/diff-neq.ts +207 -0
  206. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  207. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  208. package/src/prover/smt/solver/dt2bv-tactic.ts +298 -0
  209. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  210. package/src/prover/smt/solver/e-matching.ts +7 -8
  211. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  212. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  213. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  214. package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
  215. package/src/prover/smt/solver/enode.ts +100 -3
  216. package/src/prover/smt/solver/eq2bv-tactic.ts +227 -0
  217. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  218. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  219. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  220. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  221. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  222. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  223. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  224. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  225. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  226. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  227. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  228. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  229. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  230. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  231. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  232. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  233. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  234. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  235. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  236. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  237. package/src/prover/smt/solver/expr-ref.ts +0 -1
  238. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  239. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  240. package/src/prover/smt/solver/factor.ts +163 -0
  241. package/src/prover/smt/solver/fd-solver.ts +734 -0
  242. package/src/prover/smt/solver/fingerprints.ts +15 -15
  243. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  244. package/src/prover/smt/solver/flat-literals.ts +0 -1
  245. package/src/prover/smt/solver/fm-tactic.ts +886 -0
  246. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  247. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  248. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  249. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  250. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  251. package/src/prover/smt/solver/goal.ts +178 -15
  252. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  253. package/src/prover/smt/solver/guard-set.ts +219 -0
  254. package/src/prover/smt/solver/hash.ts +0 -1
  255. package/src/prover/smt/solver/hashtable.ts +34 -16
  256. package/src/prover/smt/solver/inf-eps.ts +63 -0
  257. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  258. package/src/prover/smt/solver/internalizer.ts +111 -39
  259. package/src/prover/smt/solver/lackr.ts +381 -0
  260. package/src/prover/smt/solver/lbool.ts +0 -1
  261. package/src/prover/smt/solver/lia2card.ts +268 -0
  262. package/src/prover/smt/solver/lia2pb.ts +154 -0
  263. package/src/prover/smt/solver/literal.ts +0 -1
  264. package/src/prover/smt/solver/logic-tactics.ts +355 -0
  265. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  266. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  267. package/src/prover/smt/solver/lp/containers.ts +7 -2
  268. package/src/prover/smt/solver/lp/core-solver.ts +30 -11
  269. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  270. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  271. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  272. package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
  273. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  274. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  275. package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
  276. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  277. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  278. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  279. package/src/prover/smt/solver/lp/lar-solver.ts +41 -5
  280. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  281. package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
  282. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  283. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  284. package/src/prover/smt/solver/lp/nex.ts +2 -2
  285. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  286. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  287. package/src/prover/smt/solver/lp/nla-core.ts +68 -17
  288. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  289. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  290. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  291. package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
  292. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  293. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  294. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  295. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  296. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  297. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  298. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  299. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  300. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  301. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  302. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  303. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  304. package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
  305. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  306. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  307. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  308. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  309. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  310. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  311. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  312. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  313. package/src/prover/smt/solver/macro-finder.ts +530 -0
  314. package/src/prover/smt/solver/mam-compiler.ts +122 -90
  315. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  316. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  317. package/src/prover/smt/solver/max-cliques.ts +105 -0
  318. package/src/prover/smt/solver/maxcore.ts +310 -0
  319. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  320. package/src/prover/smt/solver/maxlex.ts +115 -0
  321. package/src/prover/smt/solver/maxsmt-base.ts +106 -0
  322. package/src/prover/smt/solver/maxsmt.ts +92 -0
  323. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  324. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  325. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  326. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  327. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  328. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  329. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  330. package/src/prover/smt/solver/model-checker.ts +19 -28
  331. package/src/prover/smt/solver/model-evaluator.ts +190 -12
  332. package/src/prover/smt/solver/model-finder.ts +12 -18
  333. package/src/prover/smt/solver/model-generator.ts +104 -35
  334. package/src/prover/smt/solver/model-macro-solver.ts +49 -46
  335. package/src/prover/smt/solver/model-printer.ts +214 -0
  336. package/src/prover/smt/solver/mpf.ts +709 -0
  337. package/src/prover/smt/solver/mus.ts +50 -0
  338. package/src/prover/smt/solver/muz/dl-context.ts +382 -0
  339. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  340. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  341. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  342. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  343. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  344. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  345. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  346. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  347. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  348. package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
  349. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  350. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  351. package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
  352. package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
  353. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  354. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  355. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  356. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  357. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  358. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  359. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  360. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  361. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  362. package/src/prover/smt/solver/nlqsat.ts +485 -0
  363. package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
  364. package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
  365. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  366. package/src/prover/smt/solver/nlsat/explain.ts +427 -229
  367. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  368. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -246
  369. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  370. package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
  371. package/src/prover/smt/solver/nlsat/solver.ts +293 -92
  372. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  373. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  374. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  375. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
  376. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
  377. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  378. package/src/prover/smt/solver/nnf.ts +110 -24
  379. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  380. package/src/prover/smt/solver/occf.ts +97 -0
  381. package/src/prover/smt/solver/opt-context.ts +801 -0
  382. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  383. package/src/prover/smt/solver/opt-pareto.ts +301 -0
  384. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  385. package/src/prover/smt/solver/opt-solver.ts +312 -0
  386. package/src/prover/smt/solver/opt-value.ts +55 -0
  387. package/src/prover/smt/solver/optsmt.ts +692 -0
  388. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  389. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  390. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  391. package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
  392. package/src/prover/smt/solver/poly-rewriter.ts +259 -57
  393. package/src/prover/smt/solver/probes.ts +577 -0
  394. package/src/prover/smt/solver/propagate-values.ts +37 -21
  395. package/src/prover/smt/solver/proto-model.ts +648 -19
  396. package/src/prover/smt/solver/pull-quant.ts +28 -12
  397. package/src/prover/smt/solver/purify-arith.ts +634 -0
  398. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  399. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  400. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  401. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  402. package/src/prover/smt/solver/qe-lite.ts +39 -19
  403. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  404. package/src/prover/smt/solver/qe.ts +1499 -0
  405. package/src/prover/smt/solver/qel.ts +25 -0
  406. package/src/prover/smt/solver/qi-queue.ts +0 -1
  407. package/src/prover/smt/solver/qsat.ts +829 -0
  408. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  409. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  410. package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
  411. package/src/prover/smt/solver/quantifier-manager.ts +22 -25
  412. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  413. package/src/prover/smt/solver/random-gen.ts +0 -1
  414. package/src/prover/smt/solver/rational.ts +45 -1
  415. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  416. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  417. package/src/prover/smt/solver/reduce-args.ts +225 -0
  418. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  419. package/src/prover/smt/solver/ref-vector.ts +0 -1
  420. package/src/prover/smt/solver/relevancy.ts +1 -2
  421. package/src/prover/smt/solver/rewriter-tpl.ts +82 -14
  422. package/src/prover/smt/solver/rewriter.ts +505 -60
  423. package/src/prover/smt/solver/rlimit.ts +45 -5
  424. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  425. package/src/prover/smt/solver/sat/big.ts +177 -0
  426. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  427. package/src/prover/smt/solver/sat/clause.ts +203 -0
  428. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  429. package/src/prover/smt/solver/sat/config.ts +122 -0
  430. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  431. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  432. package/src/prover/smt/solver/sat/goal2sat.ts +589 -0
  433. package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
  434. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  435. package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
  436. package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
  437. package/src/prover/smt/solver/sat/probing.ts +170 -0
  438. package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
  439. package/src/prover/smt/solver/sat/sat2goal.ts +190 -0
  440. package/src/prover/smt/solver/sat/scc.ts +142 -0
  441. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  442. package/src/prover/smt/solver/sat/solver.ts +2107 -0
  443. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  444. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  445. package/src/prover/smt/solver/search-tree.ts +284 -0
  446. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  447. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  448. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  449. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  450. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  451. package/src/prover/smt/solver/seq-factory.ts +89 -0
  452. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  453. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  454. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  455. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  456. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  457. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  458. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  459. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  460. package/src/prover/smt/solver/seq-subset.ts +165 -0
  461. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  462. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  463. package/src/prover/smt/solver/smt-kernel.ts +124 -0
  464. package/src/prover/smt/solver/smt-logics.ts +66 -0
  465. package/src/prover/smt/solver/smt-setup.ts +589 -0
  466. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  467. package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
  468. package/src/prover/smt/solver/smtlib-script.ts +2136 -0
  469. package/src/prover/smt/solver/solve-eqs.ts +928 -0
  470. package/src/prover/smt/solver/solver.ts +128 -23
  471. package/src/prover/smt/solver/static-features.ts +314 -0
  472. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  473. package/src/prover/smt/solver/tactic.ts +2176 -0
  474. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  475. package/src/prover/smt/solver/theory-array.ts +1240 -0
  476. package/src/prover/smt/solver/theory-bv.ts +1210 -0
  477. package/src/prover/smt/solver/theory-char.ts +355 -0
  478. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  479. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  480. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  481. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  482. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
  483. package/src/prover/smt/solver/theory-lra-final-check.ts +57 -70
  484. package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
  485. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  486. package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
  487. package/src/prover/smt/solver/theory-lra-state.ts +7 -23
  488. package/src/prover/smt/solver/theory-lra.ts +189 -2
  489. package/src/prover/smt/solver/theory-pb.ts +951 -0
  490. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  491. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  492. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  493. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  494. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  495. package/src/prover/smt/solver/theory-seq.ts +961 -0
  496. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  497. package/src/prover/smt/solver/theory.ts +189 -0
  498. package/src/prover/smt/solver/tseitin-cnf.ts +495 -0
  499. package/src/prover/smt/solver/var-subst.ts +36 -14
  500. package/src/prover/smt/table.ts +3 -2
  501. package/src/prover/smt/types.ts +146 -0
  502. package/src/prover/tlapm/cache.ts +57 -26
  503. package/src/prover/tlapm/tlapm.ts +15 -9
  504. package/src/prover/tlapm-library.ts +3208 -0
  505. package/src/prover/verdict.ts +9 -0
  506. package/src/prover/zenon/check/check.ts +1 -2
  507. package/src/prover/zenon/check/records.ts +1 -1
  508. package/src/prover/zenon/check/relations.ts +2 -1
  509. package/src/prover/zenon/check/rewrites.ts +2 -15
  510. package/src/prover/zenon/check/sets.ts +40 -58
  511. package/src/prover/zenon/check/terms.ts +1 -2
  512. package/src/prover/zenon/decide.ts +10 -7
  513. package/src/prover/zenon/encode.ts +0 -2
  514. package/src/prover/zenon/eqrel.ts +2 -2
  515. package/src/prover/zenon/equality-rules.ts +24 -2
  516. package/src/prover/zenon/expr.ts +28 -2
  517. package/src/prover/zenon/index-table.ts +16 -23
  518. package/src/prover/zenon/isar-case.ts +1 -3
  519. package/src/prover/zenon/isar.ts +37 -39
  520. package/src/prover/zenon/llproof.ts +2 -13
  521. package/src/prover/zenon/mltoll.ts +12 -30
  522. package/src/prover/zenon/node.ts +20 -5
  523. package/src/prover/zenon/parse.ts +9 -8
  524. package/src/prover/zenon/phrase.ts +1 -3
  525. package/src/prover/zenon/proof.ts +0 -2
  526. package/src/prover/zenon/propositional-rules.ts +0 -2
  527. package/src/prover/zenon/rules.ts +2 -3
  528. package/src/prover/zenon/search.ts +11 -19
  529. package/src/prover/zenon/tla/functions.ts +2 -4
  530. package/src/prover/zenon/tla/llproof.ts +9 -13
  531. package/src/prover/zenon/tla/records.ts +1 -8
  532. package/src/prover/zenon/tla/rewrites.ts +0 -2
  533. package/src/prover/zenon/tla/sets.ts +22 -22
  534. package/src/prover/zenon/tla/terms.ts +0 -2
  535. package/src/prover/zenon/tla/tla.ts +7 -8
  536. package/src/resolve.ts +1327 -328
  537. package/src/runtime.ts +25 -2
  538. package/src/sany/builtins.ts +10 -10
  539. package/src/sany/generation.ts +384 -0
  540. package/src/sany/generator-def-entries.ts +297 -0
  541. package/src/sany/generator-definitions.ts +688 -0
  542. package/src/sany/generator-expressions.ts +1123 -0
  543. package/src/sany/generator-proofs.ts +668 -0
  544. package/src/sany/generator.ts +161 -2625
  545. package/src/sany/levels.ts +0 -2
  546. package/src/sany/lexer.ts +32 -23
  547. package/src/sany/linter.ts +0 -2
  548. package/src/sany/modules.ts +4 -2
  549. package/src/sany/nodes.ts +3 -4
  550. package/src/sany/report.ts +3 -6
  551. package/src/sany/selectors.ts +46 -44
  552. package/src/sany/xml.ts +25 -58
  553. package/src/search.ts +513 -165
  554. package/src/simulate.ts +340 -251
  555. package/src/spec-description.ts +48 -55
  556. package/src/standard-definitions.ts +5 -0
  557. package/src/standard-modules.ts +72 -54
  558. package/src/state-graph.ts +0 -2
  559. package/src/subexpressions.ts +564 -138
  560. package/src/substitution-levels.ts +5 -4
  561. package/src/successors.ts +56 -28
  562. package/src/symmetry.ts +4 -3
  563. package/src/tableau.ts +2 -2
  564. package/src/tlc/fingerprint.ts +81 -9
  565. package/src/tlc/jar-data.ts +10 -0
  566. package/src/tlc/messages.ts +23 -18
  567. package/src/tlc/order.ts +14 -3
  568. package/src/tlc/random.ts +6 -5
  569. package/src/tlc/replay.ts +152 -58
  570. package/src/tlc/summary.ts +29 -14
  571. package/src/tlc/tlc-operators.ts +12 -11
  572. package/src/tlc/tlcext-operators.ts +87 -26
  573. package/src/tlc/trace-spec.ts +27 -60
  574. package/src/trace-liveness.ts +529 -0
  575. package/src/typed-tier.ts +6556 -0
  576. package/src/typescript/actions.ts +2 -4
  577. package/src/typescript/collections.ts +34 -20
  578. package/src/typescript/compile.ts +1 -3
  579. package/src/typescript/formula.ts +5 -3
  580. package/src/typescript/model.ts +4 -5
  581. package/src/typescript/steps.ts +20 -18
  582. package/src/typescript/types.ts +2 -2
  583. package/src/values.ts +208 -227
  584. package/src/prover/isabelle/isar/statement.ts +0 -52
  585. package/src/prover/smt/solver/z3-license.txt +0 -10
  586. package/src/prover/tlaps-module.ts +0 -510
  587. package/src/prover/zenon/LICENSE +0 -32
package/src/check.ts CHANGED
@@ -1,18 +1,14 @@
1
1
  import type { Expression } from "./ast";
2
2
  import { parseConfig, type ModelConfig } from "./config";
3
3
  import {
4
- addCoverageRelation,
5
- buildCoverage,
6
4
  countCoverageVariables,
7
5
  createCoverage,
8
- getCoverageLabel,
6
+ createCoverageEnvironment,
9
7
  getCoverageReport,
10
8
  type CoverageReport,
11
9
  } from "./coverage";
12
- import { createEnvironment } from "./environment";
13
10
  import {
14
11
  createStackOverflowError,
15
- getErrorExitCode,
16
12
  isStackOverflow,
17
13
  TlaEvaluationError,
18
14
  TlaIllegalStateError,
@@ -24,21 +20,34 @@ import {
24
20
  formatRange,
25
21
  } from "./errors";
26
22
  import {
27
- createTracingEnvironment,
28
23
  describeRange,
29
24
  getDefinition,
30
- isImpure,
31
25
  type CallStack,
32
- type Environment,
33
26
  type FingerprintFailure,
27
+ type State,
34
28
  } from "./evaluate";
29
+ import { EXIT_STATUS, setExitCode, withLivenessExitCode } from "./exit-codes";
35
30
  import {
36
- EXIT_STATUS,
37
- getExitCode,
38
- getMessageExitStatus,
39
- setExitCode,
40
- withLivenessExitCode,
41
- } from "./exit-codes";
31
+ fingerprintReplayed,
32
+ getFailureExitCode,
33
+ getReplayFailure,
34
+ type FailureOptions,
35
+ } from "./check-failure";
36
+ import {
37
+ createTraceBuilder,
38
+ NEXT_RECOVERY_FAILURE,
39
+ type Behavior,
40
+ type SearchPosition,
41
+ type TracedStep,
42
+ } from "./check-trace";
43
+ import {
44
+ createStateTable,
45
+ findStateIndex,
46
+ getStateHash,
47
+ isSameState,
48
+ markSeenState,
49
+ type StateTable,
50
+ } from "./fingerprints";
42
51
  import type { JavaOverride } from "./java-overrides";
43
52
  import {
44
53
  createLivenessChecker,
@@ -47,22 +56,27 @@ import {
47
56
  type LiveSuccessor,
48
57
  } from "./liveness-checker";
49
58
  import {
59
+ addActionCoverage,
60
+ createCheckEnvironment,
50
61
  createMissingOperatorError,
51
62
  createSearch,
52
63
  getIncompleteSuccessorMessage,
53
64
  findAssumptionViolation,
54
65
  reportInitialStatesProgress,
55
66
  reportStartup,
67
+ STOP_WALK,
68
+ walkCoveredSuccessors,
56
69
  withNextStateExitCode,
70
+ type CoveredAction,
57
71
  } from "./search";
58
72
  import {
59
73
  getActionLabel,
60
74
  getActionSignature,
61
- getInitActions,
62
- getNextActions,
75
+ getSpecDescription,
63
76
  getSpecificationValue,
64
77
  toActionValue,
65
78
  type SpecAction,
79
+ type SpecDescription,
66
80
  } from "./spec-description";
67
81
  import {
68
82
  createStateWriter,
@@ -71,6 +85,7 @@ import {
71
85
  type StateWriter,
72
86
  } from "./state-graph";
73
87
  import {
88
+ createIncompleteSuccessorError,
74
89
  forEachInitialState,
75
90
  forEachSuccessor,
76
91
  getInitialStates,
@@ -79,7 +94,6 @@ import {
79
94
  type Successor,
80
95
  } from "./successors";
81
96
  import {
82
- getCodedMessage,
83
97
  getFailureMessage,
84
98
  getWrappedException,
85
99
  isEvalException,
@@ -90,31 +104,24 @@ import {
90
104
  } from "./tlc/messages";
91
105
  import { createTautologyError } from "./liveness";
92
106
  import { KEY_SEPARATOR } from "./resolve";
93
- import { setFingerprintPolynomial } from "./tlc/fingerprint";
94
107
  import { writeTraceSpec } from "./tlc/trace-spec";
95
- import { createTlcOrder } from "./tlc/order";
96
- import {
97
- getPrimedRanges,
98
- replayInitialStates,
99
- replaySuccessors,
100
- walkSuccessors,
101
- } from "./tlc/replay";
108
+ import { replayInitialStates, replaySuccessors, walkSuccessors } from "./tlc/replay";
102
109
  import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc/summary";
103
- import { createActionRecord, createCounterExample } from "./tlc/tlcext-operators";
110
+ import {
111
+ createActionRecord,
112
+ createCounterExample,
113
+ type CounterExampleLoop,
114
+ } from "./tlc/tlcext-operators";
104
115
  import type { TlcVersion } from "./tlc/version";
116
+ import { runTypedSearch, type TypedResult } from "./typed-tier";
105
117
  import {
106
- combineHash,
107
118
  createCanonicalizer,
108
119
  createModelValue,
109
120
  formatState,
110
121
  getFingerprintError,
111
- getHeldValues,
112
122
  getModelValues,
113
- getValueHash,
114
123
  isSameValue,
115
124
  markFingerprinted,
116
- setStringOrder,
117
- setValueOptions,
118
125
  type Value,
119
126
  } from "./values";
120
127
 
@@ -146,6 +153,8 @@ export interface CheckOptions {
146
153
  isTool?: boolean;
147
154
  /** TLC's -continue: reports each violation through onProgress and goes on. */
148
155
  isContinued?: boolean;
156
+ /** Skips fingerprintDistance, which takes fingerprinting every state again after the search. */
157
+ isFingerprintDistanceSkipped?: boolean;
149
158
  moduleOperators?: ModuleOperator[];
150
159
  /** TLC's trace exploration spec, and the binary trace TLC records for it unless -noTEBin. */
151
160
  traceSpec?: TraceSpecOptions;
@@ -200,7 +209,7 @@ export type CheckProgress =
200
209
  branches: number;
201
210
  /** Whether TLC checks the complete state graph. */
202
211
  isComplete: boolean;
203
- /** How many states of the graph each branch has. */
212
+ /** How many states the graphs of all branches have together. */
204
213
  states: number;
205
214
  statistics: SearchStatistics;
206
215
  }
@@ -261,6 +270,11 @@ export interface Postcondition {
261
270
  counts?: string;
262
271
  }
263
272
 
273
+ export interface TraceFailure extends FailureMessage {
274
+ /** What the spec prints as TLC rebuilds the step it then fails to print. */
275
+ output: OutputLine[];
276
+ }
277
+
264
278
  /** An evaluation that failed during the search, with the behavior up to the state TLC was working on. */
265
279
  export interface EvaluationFailure {
266
280
  code: number;
@@ -277,19 +291,13 @@ export interface EvaluationFailure {
277
291
  /** The FingerprintException the replay raises, which TLC reports in place of the call stack. */
278
292
  fingerprint?: FingerprintFailure;
279
293
  /** How TLC reports failing again as it prints the trace, since it can't fingerprint the state. */
280
- traceFailure?: FailureMessage;
294
+ traceFailure?: TraceFailure;
281
295
  /** A POSTCONDITION that is false or fails after the trace, which TLC checks as it prints one. */
282
296
  postcondition?: Postcondition;
283
297
  /** Whether TLC stops before it prints the statistics, as it does for an illegal initial state. */
284
298
  isWithoutStatistics?: boolean;
285
299
  }
286
300
 
287
- interface ReplayFailure {
288
- callStack: Expression[];
289
- fingerprint: FingerprintFailure | undefined;
290
- replayError?: TlaEvaluationError;
291
- }
292
-
293
301
  export interface InitialStates {
294
302
  generated: number;
295
303
  distinct: number;
@@ -309,7 +317,7 @@ export interface CheckResult {
309
317
  outDegrees: number[] | undefined;
310
318
  /** The smallest distance between two fingerprints, when TLC estimates a collision from them. */
311
319
  fingerprintDistance: bigint | undefined;
312
- /** A temporal property TLC finds violated as it adds a deadlocked state, reported after. */
320
+ /** A temporal property TLC finds violated as it adds the state it stopped at to the behavior graph, reported after. */
313
321
  additionalViolation?: Violation;
314
322
  /** Where TLC's worker fails to add the state to the behavior graph after it reports a violation. */
315
323
  liveCallStack?: Expression[];
@@ -319,49 +327,12 @@ export interface CheckResult {
319
327
  coverage?: CoverageReport;
320
328
  }
321
329
 
322
- interface CoveredAction extends SpecAction {
323
- node: number;
324
- }
325
-
326
- interface Behavior {
327
- trace: TraceStep[];
328
- traceOutput?: OutputLine[];
329
- }
330
-
331
- interface TraceOptions {
332
- loopStart?: number;
333
- known?: number;
334
- }
335
-
336
330
  interface ReportedViolation extends Omit<Violation, "loopStart"> {
337
331
  loopStart?: number;
338
332
  }
339
333
 
340
- interface RebuiltState {
341
- state: Value[];
342
- level: number;
343
- }
344
-
345
- interface SearchPosition {
346
- index: number;
347
- isExpanding: boolean;
348
- candidate: Value[] | undefined;
349
- candidateLevel: number;
350
- livenessSource: number;
351
- rebuilt: RebuiltState | undefined;
352
- }
353
-
354
- interface FailureOptions {
355
- initialState?: Value[];
356
- isInitial?: boolean;
357
- outDegrees?: number[];
358
- callStack?: Expression[];
359
- fingerprint?: FingerprintFailure;
360
- replayError?: TlaEvaluationError;
361
- isNextState?: boolean;
362
- isCallStackFirst?: boolean;
363
- traceFailure?: FailureMessage;
364
- isLiveCallStack?: boolean;
334
+ interface CounterExampleOptions {
335
+ isConsole: boolean;
365
336
  }
366
337
 
367
338
  const appendTraceOutput = <Traced extends Behavior>(behavior: Traced, lines: OutputLine[]) => ({
@@ -369,26 +340,22 @@ const appendTraceOutput = <Traced extends Behavior>(behavior: Traced, lines: Out
369
340
  traceOutput: [...(behavior.traceOutput ?? []), ...lines],
370
341
  });
371
342
 
372
- const INITIAL_RECOVERY_FAILURE = "Failed to recover the initial state from its fingerprint.";
373
- const NEXT_RECOVERY_FAILURE = "Failed to recover the next state from its fingerprint.";
374
-
375
- const STOP_REPLAY = new Error("The replay stopped");
376
- const STOP_WALK = new Error("The walk stopped");
343
+ const toUnexpectedError = (error: TlaEvaluationError) =>
344
+ new TlaEvaluationError(
345
+ `${isEvalException(error) ? UNEXPECTED_EVAL_EXCEPTION : UNEXPECTED_EXCEPTION}${error.message}`,
346
+ );
377
347
 
378
- const getInitialExitCode = (error: TlaEvaluationError) => {
379
- const coded = getCodedMessage(error.message);
380
- return coded &&
381
- !coded.isEvalException &&
382
- getMessageExitStatus(coded.code) === EXIT_STATUS.configParseError
383
- ? EXIT_STATUS.configParseError
384
- : getErrorExitCode(error);
385
- };
348
+ const getTraceFailure = (error: TlaEvaluationError, output: OutputLine[]): TraceFailure => ({
349
+ ...getFailureMessage(
350
+ isEvalException(error)
351
+ ? new TlaEvaluationError(`${UNEXPECTED_EVAL_EXCEPTION}${error.message}`)
352
+ : error,
353
+ true,
354
+ ),
355
+ output,
356
+ });
386
357
 
387
- const getReplayExitCode = (error: TlaEvaluationError): number => {
388
- const inner = error.cause;
389
- if (inner instanceof TlaEvaluationError) return getReplayExitCode(inner);
390
- return error instanceof TlaModuleError ? error.exitCode : EXIT_STATUS.specEvaluationFailure;
391
- };
358
+ const STOP_REPLAY = new Error("The replay stopped");
392
359
 
393
360
  export const checkSequentially = (options: CheckOptions): CheckResult => {
394
361
  const stateWriter =
@@ -428,53 +395,24 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
428
395
  capturedLines = outer;
429
396
  }
430
397
  };
431
- const order = createTlcOrder(options.source, options.loadModule);
432
- setStringOrder(order.getStringOrder(config));
433
- setValueOptions(options);
434
- setFingerprintPolynomial(options.fingerprintPolynomial ?? 0);
435
- const specification = createEnvironment(config, {
436
- source: options.source,
437
- loadModule: options.loadModule,
438
- order,
439
- loadClass: options.loadClass,
440
- print,
441
- files: {
442
- readFile: options.readFile,
443
- writeFile: options.writeFile,
444
- makeDirectory: options.makeDirectory,
445
- },
446
- seed: options.seed,
447
- isTool: options.isTool,
448
- traceFile: options.traceSpec?.traceFile,
449
- isSanyReported: options.isSanyReported,
450
- isWarningEnabled: options.isWarningEnabled,
451
- version: options.version,
452
- moduleOperators: options.moduleOperators,
453
- });
398
+ const created = createCheckEnvironment(config, options, print);
399
+ const specification = created.specification;
454
400
  reportStartup(specification, config, options.onProgress);
455
401
  const coverage =
456
402
  options.coverage === undefined
457
403
  ? undefined
458
404
  : createCoverage(specification.environment.variables.length);
459
- const environment: Environment = coverage
460
- ? {
461
- ...specification.environment,
462
- evaluators: new WeakMap(),
463
- entryEvaluators: new WeakMap(),
464
- definitionEvaluators: new WeakMap(),
465
- coverage,
466
- }
405
+ const environment = coverage
406
+ ? createCoverageEnvironment(specification.environment, coverage)
467
407
  : specification.environment;
468
408
  const runtime = environment.runtime;
469
409
  const is174 = runtime.version === "1.7.4";
470
410
  runtime.pause = options.onPause ?? (() => {});
411
+ let description: SpecDescription | undefined;
412
+ const getDescription = () =>
413
+ (description ??= getSpecDescription(config, environment, specification.instanceActions));
471
414
  runtime.getSpecification = () =>
472
- getSpecificationValue(
473
- config,
474
- environment,
475
- specification.variableLocations,
476
- specification.instanceActions,
477
- );
415
+ getSpecificationValue(getDescription(), config, environment, specification.variableLocations);
478
416
  let searchDepth = 0;
479
417
  let computedInitialStates: InitialStates | undefined;
480
418
  const getTraceSpec = (trace: TraceStep[], loopStart: number | undefined) =>
@@ -493,6 +431,15 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
493
431
  key.startsWith(`${name}${KEY_SEPARATOR}`),
494
432
  ),
495
433
  });
434
+ const getCoverage = () =>
435
+ coverage?.relations.some((relation) => relation.kind === "next")
436
+ ? getCoverageReport(
437
+ coverage,
438
+ environment,
439
+ specification.variableLocations,
440
+ search?.getTlcOrder() ?? [],
441
+ )
442
+ : undefined;
496
443
  const createResult = (
497
444
  status: CheckStatus,
498
445
  violation?: ReportedViolation,
@@ -513,14 +460,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
513
460
  initialStates: computedInitialStates,
514
461
  outDegrees: undefined,
515
462
  fingerprintDistance: undefined,
516
- coverage: coverage?.relations.some((relation) => relation.kind === "next")
517
- ? getCoverageReport(
518
- coverage,
519
- environment,
520
- specification.variableLocations,
521
- search?.getTlcOrder() ?? [],
522
- )
523
- : undefined,
463
+ coverage: getCoverage(),
524
464
  ...(traceSpec !== undefined && { traceSpec }),
525
465
  };
526
466
  };
@@ -539,23 +479,30 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
539
479
  const createSuccess = (): CheckResult => ({
540
480
  ...createResult("success"),
541
481
  outDegrees: [...outDegrees],
542
- fingerprintDistance: getFingerprintDistance(
543
- runtime.distinctStates,
544
- runtime.generatedStates,
545
- () =>
546
- search
547
- ? search.getStoredFingerprints(states, fingerprintStates)
548
- : BigInt64Array.from(states, runtime.getFingerprint),
549
- ),
482
+ fingerprintDistance: options.isFingerprintDistanceSkipped
483
+ ? undefined
484
+ : getFingerprintDistance(runtime.distinctStates, runtime.generatedStates, (visit) =>
485
+ visit(
486
+ search
487
+ ? search.getStoredFingerprints(
488
+ exploredStates.length === 0 ? states : states.concat(exploredStates),
489
+ exploredStates.length === 0
490
+ ? fingerprintStates
491
+ : fingerprintStates.concat(exploredFingerprintStates),
492
+ )
493
+ : BigInt64Array.from(states, runtime.getFingerprint),
494
+ ),
495
+ ),
550
496
  });
551
497
 
552
498
  const search = createSearch(
553
499
  config,
554
500
  environment,
555
501
  specification.variableLocations,
556
- () => order.getDeclarationOrder("variable"),
502
+ () => created.order.getDeclarationOrder("variable"),
557
503
  options.onProgress,
558
504
  specification.moduleOperators,
505
+ specification.runtimeInvariants,
559
506
  );
560
507
  const findViolatedAssumption = () =>
561
508
  findAssumptionViolation(specification.assumptions, environment);
@@ -575,24 +522,26 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
575
522
  config.postconditions.length > 0 ||
576
523
  config.possible.length > 0 ||
577
524
  specification.moduleOperators.some((operator) => operator.kind === "postcondition");
578
- const traceSteps = new WeakMap<
579
- TraceStep,
580
- { state: Record<string, Value>; action: SpecAction | undefined }
581
- >();
582
- const getStepState = (step: TraceStep) => traceSteps.get(step)?.state ?? step.state;
525
+ const tracedSteps = new WeakMap<TraceStep, TracedStep>();
526
+ const getStepState = (step: TraceStep) => tracedSteps.get(step)?.state ?? step.state;
527
+ // TLC's Worker#doPostCondition and LiveCheck bind CounterExample to the alias of each state, while its initial states and lassos keep the states.
528
+ const getStepAlias = (step: TraceStep) => tracedSteps.get(step)?.alias ?? step.state;
583
529
  const getStepAction = (step: TraceStep) => {
584
- const action = traceSteps.get(step)?.action;
530
+ const action = tracedSteps.get(step)?.action;
585
531
  return action ? toActionValue(action) : createActionRecord(step.action);
586
532
  };
587
533
  const checkTracePostconditions = (
588
534
  trace: TraceStep[],
589
- loop: { start: number; action: Value } | undefined,
535
+ loop: CounterExampleLoop | undefined,
536
+ getState: (step: TraceStep) => Record<string, Value>,
537
+ isConsole = true,
590
538
  ) => {
591
539
  if (hasPostconditions) {
592
540
  runtime.counterExample = createCounterExample(
593
- trace.map(getStepState),
541
+ trace.map(getState),
594
542
  trace.slice(1).map(getStepAction),
595
543
  loop,
544
+ isConsole,
596
545
  );
597
546
  }
598
547
  const unwitnessed = search.findUnwitnessedPossible();
@@ -604,12 +553,14 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
604
553
  const reportViolation = (
605
554
  status: CheckStatus,
606
555
  violation: ReportedViolation,
556
+ getState = getStepAlias,
607
557
  getLoopAction?: () => Value,
608
558
  ) => {
609
559
  const start = violation.loopStart;
610
560
  const checked = checkTracePostconditions(
611
561
  violation.trace,
612
562
  start === undefined || !getLoopAction ? undefined : { start, action: getLoopAction() },
563
+ getState,
613
564
  );
614
565
  return createResult(status, {
615
566
  ...violation,
@@ -633,68 +584,47 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
633
584
  };
634
585
  const spec = search.spec;
635
586
  const getFingerprintState = search.getFingerprintState;
636
- let specNextActions: SpecAction[] | undefined;
637
- const getSpecNextActions = () =>
638
- (specNextActions ??= getNextActions(config, environment, specification.instanceActions));
639
587
  // Tool's constructor splits the next-state relation into actions before TLC checks anything.
640
- getSpecNextActions();
641
- runtime.getSuccessorAction = (state, next) =>
642
- getSpecNextActions().find((action) =>
643
- getSuccessors(action.expression, state, environment, action.scope).some((successor) =>
644
- successor.state.every((value, index) => isSameValue(value, next[index])),
645
- ),
646
- );
647
- const addCoverageRelations = (kind: "init" | "next", actions: SpecAction[]) =>
648
- actions.map((action): CoveredAction => ({
649
- ...action,
650
- node: coverage
651
- ? addCoverageRelation(
652
- coverage,
653
- kind,
654
- getCoverageLabel(action.name, action.expression, environment),
655
- action.expression,
656
- action.scope,
657
- )
658
- : -1,
659
- }));
660
- const coverageInits = addCoverageRelations(
661
- "init",
662
- coverage ? getInitActions(config, environment, specification.instanceActions) : [],
663
- );
664
- const coverageActions = addCoverageRelations("next", coverage ? getSpecNextActions() : []);
665
- if (coverage) buildCoverage(coverage, environment, getPrimedRanges(coverageActions, environment));
666
- const walkCoveredSuccessors = (
667
- action: CoveredAction,
668
- state: Value[],
669
- onState: (successor: Value[]) => void,
670
- ) =>
588
+ const nextActions = getDescription().actions;
589
+ const covered = coverage && addActionCoverage(coverage, environment, getDescription());
590
+ const coverageInits = covered?.inits ?? [];
591
+ const coverageActions = covered?.actions ?? [];
592
+ const hasCoveredIncompleteSuccessor = (action: CoveredAction, state: Value[]) => {
593
+ let complete = 0;
594
+ let incomplete = 0;
671
595
  walkSuccessors(
672
596
  action,
673
597
  action.node,
674
598
  state,
675
599
  environment,
676
- (successor) => {
677
- if (coverage) coverage.primary[action.node]++;
678
- onState(successor);
679
- },
680
- (partial) => {
681
- const missing = environment.variables.filter(
682
- (_variable, index) => partial[index] === undefined,
683
- );
684
- throw new TlaIncompleteSuccessorError(
685
- `Successor state is not completely specified by action ${action.name}. The following variables are not assigned: ${missing.join(", ")}`,
686
- partial,
687
- action.name,
688
- missing,
689
- );
600
+ () => complete++,
601
+ () => {
602
+ incomplete++;
603
+ return true;
690
604
  },
691
605
  );
692
- const getCoveredSuccessors = (action: CoveredAction, state: Value[]) => {
693
- const successors: Successor[] = [];
694
- walkCoveredSuccessors(action, state, (successor) =>
695
- successors.push({ state: successor, action: action.name }),
606
+ if (coverage) coverage.primary[action.node] += complete + incomplete;
607
+ return incomplete > 0;
608
+ };
609
+ // TLC generates the successors of each action again, which its coverage counts.
610
+ const findSuccessorAction = (state: Value[], isMatch: (successor: Successor) => boolean) =>
611
+ coverage
612
+ ? coverageActions.find((item) => {
613
+ const successors: Successor[] = [];
614
+ walkCoveredSuccessors(coverage, item, state, environment, (successor) =>
615
+ successors.push({ state: successor, action: item.name }),
616
+ );
617
+ return successors.some(isMatch);
618
+ })
619
+ : nextActions.find((item) =>
620
+ getSuccessors(item.expression, state, environment, item.scope).some(isMatch),
621
+ );
622
+ runtime.getSuccessorAction = (state, next) =>
623
+ findSuccessorAction(state, (successor) =>
624
+ successor.state.every((value, index) => isSameValue(value, next[index])),
696
625
  );
697
- return successors;
626
+ const rejectIncompleteInitialState = (partial: (Value | undefined)[]) => {
627
+ throw setExitCode(new TlaIllegalStateError([...partial]), EXIT_STATUS.error);
698
628
  };
699
629
  const getCoveredInitialStates = () => {
700
630
  const initialStates: Value[][] = [];
@@ -702,58 +632,19 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
702
632
  coverageInits,
703
633
  environment,
704
634
  (state) => initialStates.push(state),
705
- (partial) => {
706
- throw setExitCode(new TlaIllegalStateError([...partial]), EXIT_STATUS.error);
707
- },
635
+ rejectIncompleteInitialState,
708
636
  );
709
637
  return initialStates;
710
638
  };
711
- const getReplayFailure = (replay: (tracing: Environment) => void): ReplayFailure | undefined => {
712
- const tracing = createTracingEnvironment(environment);
713
- const callStack = tracing.callStack;
714
- try {
715
- replay(tracing);
716
- return undefined;
717
- } catch (error) {
718
- if (isStackOverflow(error)) return { callStack: [], fingerprint: undefined };
719
- if (!(error instanceof TlaEvaluationError) || !callStack) return undefined;
720
- return {
721
- callStack: callStack.expressions,
722
- fingerprint: callStack.fingerprint,
723
- replayError: error,
724
- };
725
- }
726
- };
727
- const findFailedSources = (value: Value, sources: CallStack["sources"]): Expression[] => {
728
- if (typeof value !== "object") return [];
729
- const source = sources.get(value);
730
- const failed = getHeldValues(value).find((held) => getFingerprintError(held) !== undefined);
731
- return [
732
- ...(source ? [source] : []),
733
- ...(failed === undefined ? [] : findFailedSources(failed, sources)),
734
- ];
735
- };
736
- const fingerprintReplayed = (state: Value[], callStack: CallStack | undefined) => {
737
- for (const value of getFingerprintState(state)) {
738
- const error = getFingerprintError(value);
739
- if (!error) continue;
740
- const sources = callStack ? findFailedSources(value, callStack.sources) : [];
741
- if (callStack && sources.length > 0) {
742
- callStack.expressions.length = 0;
743
- callStack.isFrozen = true;
744
- callStack.fingerprint = { sources, reason: error.message };
745
- }
746
- throw error;
747
- }
748
- state.forEach(markFingerprinted);
749
- };
750
639
  const createReplayedStates = () => {
751
640
  const replayed = unstoredFingerprint ? [unstoredFingerprint] : [];
752
641
  return (state: Value[], callStack: CallStack | undefined) => {
753
- fingerprintReplayed(state, callStack);
642
+ fingerprintReplayed(state, getFingerprintState(state), callStack);
754
643
  const fingerprintState = getFingerprintState(state);
644
+ const hash = getStateHash(fingerprintState);
755
645
  const isSeen =
756
- findStateIndex(getStateHash(fingerprintState), fingerprintState) !== -1 ||
646
+ findStateIndex(seenStates, hash, fingerprintState) !== -1 ||
647
+ isExplored(hash, fingerprintState) ||
757
648
  replayed.some((seen) => isSameState(seen, fingerprintState));
758
649
  if (isSeen) return false;
759
650
  replayed.push(fingerprintState);
@@ -765,48 +656,45 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
765
656
  let replayedCount = 0;
766
657
  const deferred: unknown[] = [];
767
658
  const addReplayed = createReplayedStates();
768
- return getReplayFailure((tracing) => {
769
- replayInitialStates(
770
- getInitActions(config, environment, specification.instanceActions),
771
- tracing,
772
- (state) => {
773
- reportInitialStatesProgress(replayedCount, (progress) => capturedLines?.push(progress));
774
- replayedCount++;
775
- runtime.generatedStates = replayedCount;
776
- if (deferred.length > 0) return;
777
- try {
778
- const addFingerprint = () => {
779
- if (!addReplayed(state, tracing.callStack)) return;
780
- runtime.queueSize++;
781
- liveness?.addInitialState(states.length, state, tracing);
782
- };
783
- const violation = search.checkReplayedInitialState(state, tracing, addFingerprint);
784
- if (violation) {
785
- const traced = toTrace([{ action: undefined, state }], []).trace[0].state;
786
- capturedLines?.push({
787
- kind: "initial-state-violation",
788
- ...violation,
789
- state: traced,
790
- });
659
+ return getReplayFailure(environment, (tracing) => {
660
+ replayInitialStates(coverage ? coverageInits : getDescription().inits, tracing, (state) => {
661
+ reportInitialStatesProgress(replayedCount, (progress) => capturedLines?.push(progress));
662
+ replayedCount++;
663
+ runtime.generatedStates = replayedCount;
664
+ if (deferred.length > 0) return;
665
+ try {
666
+ const addFingerprint = () => {
667
+ if (!addReplayed(state, tracing.callStack)) return;
668
+ runtime.queueSize++;
669
+ liveness?.addInitialState(states.length, state, tracing);
670
+ };
671
+ search.checkReplayedInitialState(state, tracing, addFingerprint, (violation) => {
672
+ const traced = traces.toTrace([{ action: undefined, state }], []).trace[0].state;
673
+ capturedLines?.push({
674
+ kind: "initial-state-violation",
675
+ ...violation,
676
+ state: traced,
677
+ });
678
+ if (!options.isContinued || violation.status !== "invariant-violation") {
791
679
  throw STOP_REPLAY;
792
680
  }
793
- } catch (error) {
794
- const isFingerprintFailure =
795
- error instanceof TlaEvaluationError && tracing.callStack?.fingerprint !== undefined;
796
- if (!isFingerprintFailure && !isStackOverflow(error)) throw error;
797
- deferred.push(error);
798
- }
799
- },
800
- );
681
+ });
682
+ } catch (error) {
683
+ const isFingerprintFailure =
684
+ error instanceof TlaEvaluationError && tracing.callStack?.fingerprint !== undefined;
685
+ if (!isFingerprintFailure && !isStackOverflow(error)) throw error;
686
+ deferred.push(error);
687
+ }
688
+ });
801
689
  if (deferred.length > 0) throw deferred[0];
802
690
  });
803
691
  };
804
692
  const replayNext = (index: number) =>
805
- getReplayFailure((tracing) => {
693
+ getReplayFailure(environment, (tracing) => {
806
694
  const state = states[index];
807
695
  const source = stateWriter && getGraphState(state, depths[index]);
808
696
  const addReplayed = createReplayedStates();
809
- replaySuccessors(getSpecNextActions(), state, tracing, (next, action) => {
697
+ replaySuccessors(coverage ? coverageActions : nextActions, state, tracing, (next, action) => {
810
698
  const addFingerprint = () => {
811
699
  const isUnseen = addReplayed(next, tracing.callStack);
812
700
  if (source) {
@@ -824,7 +712,6 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
824
712
  }
825
713
  });
826
714
  });
827
- const isReducing = config.view !== undefined || config.symmetry !== undefined;
828
715
  const tlcFingerprints: number[] = [];
829
716
  if (search.properties.liveness.length > 0) {
830
717
  options.onProgress?.({
@@ -833,6 +720,15 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
833
720
  isConstrained: search.isConstrained,
834
721
  });
835
722
  }
723
+ let liveState: Value[] = [];
724
+ const addIncomplete = (successor: State, action: string | undefined) => {
725
+ if (
726
+ search.satisfiesConstraints(successor, liveState) &&
727
+ search.satisfiesActionConstraints(liveState, successor)
728
+ ) {
729
+ throw createIncompleteSuccessorError(successor, action, environment);
730
+ }
731
+ };
836
732
  const liveness = withLivenessExitCode(() =>
837
733
  withUnexpectedException(() =>
838
734
  createLivenessChecker(search.properties.liveness, spec.temporals, environment, {
@@ -840,33 +736,67 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
840
736
  (tlcFingerprints[successor.index] ??= Number(
841
737
  BigInt.asIntN(32, runtime.getFingerprint(successor.state)),
842
738
  )),
843
- getSuccessors: (source, state) => {
844
- const successors: LiveSuccessor[] = [];
845
- if (spec.next === undefined) return successors;
846
- const livenessSource = current.livenessSource;
847
- current.livenessSource = source;
848
- try {
849
- forEachSuccessor(
850
- spec.next,
851
- state,
852
- environment,
853
- (successor) => {
854
- canonicalizeState(successor.state);
855
- const isInModel =
856
- search.satisfiesConstraints(successor.state, state) &&
857
- search.satisfiesActionConstraints(state, successor.state);
858
- if (!isInModel) return false;
859
- const fingerprintState = getFingerprintState(successor.state);
860
- const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
861
- successors.push({ index, state: successor.state });
862
- return false;
863
- },
864
- spec.scope,
865
- );
866
- } finally {
867
- current.livenessSource = livenessSource;
739
+ forEachActionSuccessors: (source, state, onSuccessors, replay) => {
740
+ liveState = state;
741
+ let successors: LiveSuccessor[] = [];
742
+ const addSuccessor = (successor: Value[]) => {
743
+ canonicalizeState(successor);
744
+ const isInModel =
745
+ search.satisfiesConstraints(successor, state) &&
746
+ search.satisfiesActionConstraints(state, successor);
747
+ if (!isInModel) return;
748
+ const fingerprintState = getFingerprintState(successor);
749
+ const hash = getStateHash(fingerprintState);
750
+ const index = findStateIndex(seenStates, hash, fingerprintState);
751
+ successors.push({
752
+ index: index === -1 ? getPendingIndex(hash, fingerprintState) : index,
753
+ state: successor,
754
+ });
755
+ };
756
+ const visitSuccessor = (successor: Successor) => {
757
+ addSuccessor(successor.state);
758
+ return false;
759
+ };
760
+ const actionCount = coverage ? coverageActions.length : nextActions.length;
761
+ for (let position = 0; position < actionCount; position++) {
762
+ successors = [];
763
+ const livenessSource = current.livenessSource;
764
+ current.livenessSource = source;
765
+ try {
766
+ if (coverage) {
767
+ // TLC's coverage counts the successors of each action the graph generates again.
768
+ walkCoveredSuccessors(
769
+ coverage,
770
+ coverageActions[position],
771
+ state,
772
+ replay ?? environment,
773
+ addSuccessor,
774
+ addIncomplete,
775
+ );
776
+ } else if (replay) {
777
+ const action = nextActions[position];
778
+ walkSuccessors(action, -1, state, replay, addSuccessor, (partial) => {
779
+ addIncomplete(partial, action.name);
780
+ return true;
781
+ });
782
+ } else {
783
+ const action = nextActions[position];
784
+ forEachSuccessor(
785
+ action.expression,
786
+ state,
787
+ environment,
788
+ visitSuccessor,
789
+ action.scope,
790
+ undefined,
791
+ undefined,
792
+ addIncomplete,
793
+ );
794
+ }
795
+ } finally {
796
+ current.livenessSource = livenessSource;
797
+ }
798
+ onSuccessors(successors);
868
799
  }
869
- return successors;
870
800
  },
871
801
  }),
872
802
  ),
@@ -880,202 +810,32 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
880
810
  const parents: number[] = [];
881
811
  const actions: (string | undefined)[] = [];
882
812
  const depths: number[] = [];
883
- // A Map holds at most 2^24 entries, so an open-addressing table keeps each hash and index + 1.
884
- const seenStates = { slots: new Int32Array(1 << 17), size: 0, shift: 16 };
885
- const canonicalizeState = createCanonicalizer();
886
-
887
- const toRecord = search.toRecord;
888
- const getAliasState = (
889
- alias: string,
890
- steps: Successor[],
891
- position: number,
892
- loopStart: number | undefined,
893
- ) => {
894
- const searchLevel = runtime.getLevel;
895
- const searchBehavior = runtime.getBehavior;
896
- runtime.getLevel = () => position + 1;
897
- runtime.getBehavior = () => steps.slice(0, position + 1).map((step) => step.state);
898
- try {
899
- return evaluateAlias(
900
- alias,
901
- steps[position].state,
902
- (steps[position + 1] ?? steps[loopStart ?? position]).state,
903
- );
904
- } finally {
905
- runtime.getLevel = searchLevel;
906
- runtime.getBehavior = searchBehavior;
907
- }
908
- };
909
- const evaluateAlias = (alias: string, state: Value[], next: Value[] | undefined) =>
910
- search.evaluateAlias(alias, state, next, options.isTool ?? false);
911
- const findStepAction = (index: number, previous: Value[], state: Value[], isHeld: boolean) => {
912
- const actions = getSpecNextActions();
913
- const expanding = { ...current };
914
- Object.assign(current, {
915
- index,
916
- isExpanding: true,
917
- candidate: undefined,
918
- rebuilt: { state: previous, level: depths[index] },
919
- });
920
- const getKey = isHeld ? (values: Value[]) => values : getFingerprintState;
921
- const key = getKey(state);
922
- try {
923
- return coverage
924
- ? coverageActions.find((item) =>
925
- getCoveredSuccessors(item, previous).some((successor) =>
926
- isSameState(getKey(successor.state), key),
927
- ),
928
- )
929
- : actions.find((item) =>
930
- getSuccessors(item.expression, previous, environment, item.scope).some((successor) =>
931
- isSameState(getKey(successor.state), key),
932
- ),
933
- );
934
- } finally {
935
- Object.assign(current, expanding);
813
+ const seenStates = createStateTable(fingerprintStates);
814
+ const exploredStates: Value[][] = [];
815
+ const exploredFingerprintStates: Value[][] = [];
816
+ let exploredTable: StateTable | undefined;
817
+ const isExplored = (hash: number, fingerprintState: Value[]) =>
818
+ exploredTable !== undefined && findStateIndex(exploredTable, hash, fingerprintState) !== -1;
819
+ const pendingFingerprintStates: Value[][] = [];
820
+ let pendingStates: StateTable | undefined;
821
+ const getPendingIndex = (hash: number, fingerprintState: Value[]) => {
822
+ pendingStates ??= createStateTable(pendingFingerprintStates);
823
+ const found = findStateIndex(pendingStates, hash, fingerprintState);
824
+ const position = found === -1 ? pendingFingerprintStates.length : found;
825
+ if (found === -1) {
826
+ markSeenState(pendingStates, hash, position);
827
+ pendingFingerprintStates.push(fingerprintState);
936
828
  }
829
+ return -2 - position;
937
830
  };
938
- const toTrace = (
939
- steps: Successor[],
940
- path: number[],
941
- traceOptions: TraceOptions = {},
942
- ): Behavior => {
943
- const alias = config.alias;
944
- const known = traceOptions.known ?? 1;
945
- const initialOutput = steps.length > 1 ? captureOutput(getSpecInitialStates).lines : [];
946
- const stepActions = steps.map((step, position) =>
947
- position === 0 || step.action === "Stuttering"
948
- ? { result: undefined, lines: [] }
949
- : captureOutput(() =>
950
- findStepAction(
951
- path[position - 1],
952
- steps[position - 1].state,
953
- step.state,
954
- known === 2 && position === steps.length - 1,
955
- ),
956
- ),
957
- );
958
- const outputs = stepActions.map((step) => step.lines);
959
- const loopStart = traceOptions.loopStart;
960
- const rebuilt = is174 && loopStart !== undefined ? loopStart + 1 : steps.length - known;
961
- if (coverage && steps.length > 1) {
962
- const isRebuiltAgain = known > 0 && !is174;
963
- if (rebuilt > 0 && isRebuiltAgain) captureOutput(getSpecInitialStates);
964
- if (isRebuiltAgain) {
965
- steps.slice(1).forEach((step, position) => {
966
- if (step.action === "Stuttering") return;
967
- captureOutput(() =>
968
- findStepAction(
969
- path[position],
970
- steps[position].state,
971
- step.state,
972
- known === 2 && position === steps.length - 2,
973
- ),
974
- );
975
- });
976
- }
977
- }
978
- const prefixOutput = rebuilt > 0 ? [initialOutput, ...outputs.slice(1, rebuilt)].flat() : [];
979
- return {
980
- trace: steps.map((step, position) => {
981
- const action = stepActions[position].result;
982
- const traceStep: TraceStep = {
983
- action: step.action,
984
- label: action && getActionLabel(action, options.version),
985
- state:
986
- alias === undefined
987
- ? toRecord(step.state)
988
- : getAliasState(alias, steps, position, loopStart),
989
- output: position === 0 ? prefixOutput : position < rebuilt ? [] : outputs[position],
990
- };
991
- if (alias !== undefined || action) {
992
- traceSteps.set(traceStep, { state: toRecord(step.state), action });
993
- }
994
- return traceStep;
995
- }),
996
- traceOutput: known > 0 && !is174 ? [initialOutput, ...outputs].flat() : [],
997
- };
998
- };
999
- const getSpecInitialStates = () => {
1000
- if (coverage) return getCoveredInitialStates();
1001
- return spec.init === undefined ? [] : getInitialStates(spec.init, environment, spec.scope);
1002
- };
1003
- const findTraceSuccessor = (state: Value[], isMatch: (successor: Successor) => boolean) =>
1004
- captureOutput(() => {
1005
- for (const action of getSpecNextActions()) {
1006
- const successor = getSuccessors(action.expression, state, environment, action.scope).find(
1007
- isMatch,
1008
- );
1009
- if (successor) return { ...successor, action: successor.action ?? action.name };
1010
- }
1011
- return undefined;
1012
- }).result;
1013
- const hasFingerprint = (state: Value[], index: number) =>
1014
- isSameState(getFingerprintState(state), fingerprintStates[index]);
1015
- const findSuccessorWithFingerprint = (state: Value[], index: number) =>
1016
- findTraceSuccessor(state, (successor) => hasFingerprint(successor.state, index));
1017
- const getPathStates = (path: number[], nextFailure: string) => {
1018
- const initial = captureOutput(() =>
1019
- isReducing || isImpure(environment)
1020
- ? getSpecInitialStates().find((state) => hasFingerprint(state, path[0]))
1021
- : states[path[0]],
1022
- ).result;
1023
- if (!initial) throw new TlaEvaluationError(INITIAL_RECOVERY_FAILURE);
1024
- const steps: Successor[] = [{ state: initial, action: undefined }];
1025
- for (let position = 1; position < path.length; position++) {
1026
- const previous = steps[position - 1].state;
1027
- if (path[position - 1] === path[position]) {
1028
- steps.push({ state: previous, action: "Stuttering" });
1029
- continue;
1030
- }
1031
- const rebuilt = current.rebuilt;
1032
- current.rebuilt = { state: previous, level: depths[path[position - 1]] };
1033
- const successor = findSuccessorWithFingerprint(previous, path[position]);
1034
- current.rebuilt = rebuilt;
1035
- if (!successor) throw new TlaEvaluationError(nextFailure);
1036
- steps.push(successor);
1037
- }
1038
- return steps;
1039
- };
1040
- const getTrace = (index: number, lastSuccessor?: Successor) => {
1041
- const path: number[] = [];
1042
- for (let position = index; position !== -1; position = parents[position]) {
1043
- path.unshift(position);
1044
- }
1045
- const steps =
1046
- isReducing && path.length > 1
1047
- ? getPathStates(path, INITIAL_RECOVERY_FAILURE)
1048
- : path.map((position) => ({ state: states[position], action: actions[position] }));
1049
- if (!lastSuccessor) return toTrace(steps, path);
1050
- const action = isReducing
1051
- ? findTraceSuccessor(states[index], (successor) =>
1052
- isSameState(successor.state, lastSuccessor.state),
1053
- )?.action
1054
- : lastSuccessor.action;
1055
- return toTrace([...steps, { state: lastSuccessor.state, action }], path, { known: 2 });
1056
- };
1057
- // Deviation from TLC: TLCTrace#printTrace prints a lone initial state without the alias.
1058
- const getStateTrace = (index: number): Behavior =>
1059
- parents[index] === -1
1060
- ? {
1061
- trace: [
1062
- {
1063
- action: undefined,
1064
- label: undefined,
1065
- state:
1066
- config.alias === undefined
1067
- ? toRecord(states[index])
1068
- : getAliasState(
1069
- config.alias,
1070
- [{ state: states[index], action: undefined }],
1071
- 0,
1072
- undefined,
1073
- ),
1074
- },
1075
- ],
1076
- traceOutput: is174 ? [] : captureOutput(getSpecInitialStates).lines,
1077
- }
1078
- : getTrace(index);
831
+ // TLC's states keep their own values, and coverage charges the cost model each value carries.
832
+ const canonicalizeState = coverage ? (state: Value[]) => state : createCanonicalizer();
833
+
834
+ const toRecord = search.toRecord;
835
+ const getUncoveredInitialStates = () =>
836
+ spec.init === undefined ? [] : getInitialStates(spec.init, environment, spec.scope);
837
+ const getSpecInitialStates = () =>
838
+ coverage ? getCoveredInitialStates() : getUncoveredInitialStates();
1079
839
  const isUnfingerprintable = (state: Value[]) => {
1080
840
  try {
1081
841
  return getFingerprintState(state).some((value) => getFingerprintError(value) !== undefined);
@@ -1084,85 +844,112 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1084
844
  return true;
1085
845
  }
1086
846
  };
1087
- const getFailedTrace = (index: number, successor: Successor): Behavior => ({
1088
- trace: getTrace(index, successor).trace,
1089
- });
1090
- const getFailureExitCode = (error: TlaEvaluationError, failureOptions: FailureOptions) => {
1091
- if (
1092
- failureOptions.isInitial &&
1093
- !failureOptions.callStack &&
1094
- !failureOptions.fingerprint &&
1095
- is174
1096
- ) {
1097
- return EXIT_STATUS.success;
1098
- }
1099
- if (!failureOptions.callStack) {
1100
- return failureOptions.isInitial ? getInitialExitCode(error) : getErrorExitCode(error);
1101
- }
1102
- if (failureOptions.isCallStackFirst) return getErrorExitCode(error);
1103
- if (failureOptions.isLiveCallStack) {
1104
- return (
1105
- getExitCode(error) ?? (error instanceof TlaModuleError ? error.exitCode : EXIT_STATUS.error)
1106
- );
1107
- }
1108
- return failureOptions.isInitial || failureOptions.fingerprint
1109
- ? EXIT_STATUS.specEvaluationFailure
1110
- : getReplayExitCode(failureOptions.replayError ?? error);
847
+ const checkFailedTrace = (behavior: Behavior, counterExample?: CounterExampleOptions) => {
848
+ if (!counterExample) return { behavior, postcondition: undefined };
849
+ const checked = checkTracePostconditions(
850
+ behavior.trace,
851
+ undefined,
852
+ getStepAlias,
853
+ counterExample.isConsole,
854
+ );
855
+ return {
856
+ behavior: appendTraceOutput(behavior, checked.lines),
857
+ postcondition: checked.unwitnessed ?? checked.postcondition,
858
+ };
1111
859
  };
1112
860
  const createFailureResult = (
1113
861
  failed: unknown,
1114
862
  behavior: Behavior,
1115
863
  failureOptions: FailureOptions = {},
864
+ postcondition?: Postcondition,
1116
865
  ) => {
1117
866
  const error = isStackOverflow(failed) ? new TlaStackOverflowError() : failed;
1118
867
  if (!(error instanceof TlaEvaluationError)) throw error;
1119
- const checked =
1120
- behavior.trace.length > 0 && !failureOptions.traceFailure
1121
- ? checkTracePostconditions(behavior.trace, undefined)
1122
- : undefined;
1123
- const postcondition = checked?.unwitnessed ?? checked?.postcondition;
1124
- const traceOutput = [...(behavior.traceOutput ?? []), ...(checked?.lines ?? [])];
1125
868
  return {
1126
869
  ...createResult("error", undefined, {
1127
- ...getFailureMessage(error, failureOptions.isNextState ?? false),
870
+ ...getFailureMessage(
871
+ error,
872
+ failureOptions.phase !== undefined && failureOptions.phase !== "initial",
873
+ ),
1128
874
  ...behavior,
1129
- ...(traceOutput.length > 0 && { traceOutput }),
1130
875
  ...(postcondition && { postcondition }),
1131
876
  initialState:
1132
877
  failureOptions.initialState && !(error instanceof TlaModuleError)
1133
878
  ? toRecord(failureOptions.initialState)
1134
879
  : undefined,
1135
- exitCode: getFailureExitCode(error, failureOptions),
880
+ exitCode: getFailureExitCode(error, failureOptions, is174),
1136
881
  callStack: failureOptions.callStack,
1137
- ...(failureOptions.isCallStackFirst && { isCallStackFirst: true }),
882
+ ...(failureOptions.phase === "liveness" && { isCallStackFirst: true }),
1138
883
  ...(failureOptions.fingerprint && { fingerprint: failureOptions.fingerprint }),
1139
884
  ...(failureOptions.traceFailure && { traceFailure: failureOptions.traceFailure }),
1140
885
  }),
1141
886
  outDegrees: failureOptions.outDegrees,
1142
887
  };
1143
888
  };
1144
- const reportIncompleteSuccessor = (index: number, error: TlaIncompleteSuccessorError) => {
889
+ // Deviation from TLC: Worker#doPostCondition throws an ArrayIndexOutOfBoundsException at an incomplete successor, where tla-ts checks the postconditions with the successor in CounterExample.
890
+ const reportIncompleteSuccessor = (
891
+ index: number,
892
+ error: TlaIncompleteSuccessorError,
893
+ liveSuccessors: LiveSuccessor[],
894
+ ) => {
1145
895
  runtime.generatedStates++;
1146
- const actions = getSpecNextActions();
1147
- const named =
1148
- actions.length === 1 ? actions : actions.filter((item) => item.name === error.action);
1149
- const action =
1150
- named.length === 1
1151
- ? named[0]
1152
- : captureOutput(() =>
1153
- named.find((item) =>
1154
- hasIncompleteSuccessor(item.expression, states[index], environment, item.scope),
1155
- ),
1156
- ).result;
896
+ const found = captureOutput(() => {
897
+ try {
898
+ return {
899
+ action: coverage
900
+ ? coverageActions.find((item) => hasCoveredIncompleteSuccessor(item, states[index]))
901
+ : nextActions.find((item) =>
902
+ hasIncompleteSuccessor(item.expression, states[index], environment, item.scope),
903
+ ),
904
+ failed: undefined,
905
+ };
906
+ } catch (failed) {
907
+ if (!(failed instanceof TlaEvaluationError)) throw failed;
908
+ return { action: undefined, failed };
909
+ }
910
+ });
911
+ const action = found.result.action;
912
+ const traceFailure = found.result.failed && getTraceFailure(found.result.failed, found.lines);
1157
913
  const message = getIncompleteSuccessorMessage(
1158
914
  error.variables,
1159
915
  error.action,
1160
- actions.length,
916
+ nextActions.length,
1161
917
  options.version,
1162
918
  );
1163
- const undefinedValue = createModelValue("null");
1164
- const partial = error.state.map((value) => value ?? undefinedValue);
1165
- const failure = createFailureResult(error, getStateTrace(index));
919
+ const live = captureOutput(() => addFailedLiveState(index, liveSuccessors));
920
+ const trace = traces.getStateTrace(index, {
921
+ incomplete: error.state,
922
+ isPrintedOnly: true,
923
+ }).trace;
924
+ const checked = checkFailedTrace(
925
+ appendTraceOutput(
926
+ {
927
+ trace: traceFailure
928
+ ? trace
929
+ : [
930
+ ...trace,
931
+ traces.getIncompleteStep(
932
+ error.state,
933
+ trace.length + 1,
934
+ {
935
+ action: error.action,
936
+ label: action && getActionLabel(action, options.version),
937
+ output: found.lines,
938
+ },
939
+ action,
940
+ ),
941
+ ],
942
+ },
943
+ live.lines,
944
+ ),
945
+ { isConsole: true },
946
+ );
947
+ const failure = createFailureResult(
948
+ error,
949
+ checked.behavior,
950
+ { callStack: live.result, traceFailure },
951
+ checked.postcondition,
952
+ );
1166
953
  return withOutDegrees({
1167
954
  ...failure,
1168
955
  failure: failure.failure && {
@@ -1171,79 +958,18 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1171
958
  message,
1172
959
  toolMessage: message,
1173
960
  exitCode: EXIT_STATUS.specEvaluationFailure,
1174
- trace: [
1175
- ...failure.failure.trace,
1176
- {
1177
- action: error.action,
1178
- label: action && getActionLabel(action, options.version),
1179
- state: toRecord(partial),
1180
- },
1181
- ],
1182
961
  },
1183
962
  });
1184
963
  };
1185
- const getPathSteps = (path: number[], loopStart?: number) => {
1186
- const steps = getPathStates(path, NEXT_RECOVERY_FAILURE);
1187
- const lastState = steps[steps.length - 1].state;
1188
- const isClosed =
1189
- !isReducing ||
1190
- loopStart === undefined ||
1191
- loopStart === path.length - 1 ||
1192
- findSuccessorWithFingerprint(lastState, path[loopStart]) !== undefined;
1193
- if (!isClosed) throw new TlaEvaluationError(NEXT_RECOVERY_FAILURE);
1194
- return steps;
1195
- };
1196
- const getStateHash = (state: Value[]) => {
1197
- let hash = 0x811c9dc5;
1198
- for (let index = 0; index < state.length; index++)
1199
- hash = combineHash(hash, getValueHash(state[index]));
1200
- return hash & 0x3fffffff;
1201
- };
1202
964
  const fingerprintModelState = (state: Value[]) => {
1203
965
  for (const value of state) {
1204
966
  const error = getFingerprintError(value);
1205
967
  if (error) throw error;
1206
968
  }
1207
969
  };
1208
- const isSameState = (stored: Value[], state: Value[]) => {
1209
- for (let position = 0; position < state.length; position++) {
1210
- if (!isSameValue(stored[position], state[position])) return false;
1211
- }
1212
- return true;
1213
- };
1214
- const getSlot = (hash: number) => (Math.imul(hash, 0x9e3779b1) >>> seenStates.shift) << 1;
1215
- const findStateIndex = (hash: number, state: Value[]) => {
1216
- const mask = seenStates.slots.length - 1;
1217
- for (let slot = getSlot(hash); ; slot = (slot + 2) & mask) {
1218
- const entry = seenStates.slots[slot + 1];
1219
- if (entry === 0) return -1;
1220
- if (seenStates.slots[slot] === hash && isSameState(fingerprintStates[entry - 1], state)) {
1221
- return entry - 1;
1222
- }
1223
- }
1224
- };
1225
- const insertSeen = (hash: number, entry: number) => {
1226
- const mask = seenStates.slots.length - 1;
1227
- let slot = getSlot(hash);
1228
- while (seenStates.slots[slot + 1] !== 0) slot = (slot + 2) & mask;
1229
- seenStates.slots[slot] = hash;
1230
- seenStates.slots[slot + 1] = entry;
1231
- };
1232
- const markSeen = (hash: number, index: number) => {
1233
- seenStates.size++;
1234
- if (seenStates.size * 4 > seenStates.slots.length) {
1235
- const slots = seenStates.slots;
1236
- seenStates.slots = new Int32Array(slots.length * 2);
1237
- seenStates.shift--;
1238
- for (let slot = 0; slot < slots.length; slot += 2) {
1239
- if (slots[slot + 1] !== 0) insertSeen(slots[slot], slots[slot + 1]);
1240
- }
1241
- }
1242
- insertSeen(hash, index + 1);
1243
- };
1244
970
  let unstoredFingerprint: Value[] | undefined;
1245
971
  const countDistinctState = (depth: number) => {
1246
- runtime.distinctStates = states.length + 1;
972
+ runtime.distinctStates = states.length + exploredStates.length + 1;
1247
973
  searchDepth = Math.max(searchDepth, depth);
1248
974
  runtime.diameter = Math.max(runtime.diameter, depth);
1249
975
  };
@@ -1269,17 +995,50 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1269
995
  livenessSource: -1,
1270
996
  rebuilt: undefined,
1271
997
  };
998
+ const traces = createTraceBuilder({
999
+ config,
1000
+ options,
1001
+ environment,
1002
+ search,
1003
+ nextActions,
1004
+ current,
1005
+ states,
1006
+ fingerprintStates,
1007
+ parents,
1008
+ actions,
1009
+ depths,
1010
+ tracedSteps,
1011
+ captureOutput,
1012
+ getInitialStates: getSpecInitialStates,
1013
+ getUncoveredInitialStates,
1014
+ findSuccessorAction,
1015
+ });
1272
1016
  const getPath = (index: number): Value[][] =>
1273
1017
  index === -1 ? [] : [...getPath(parents[index]), states[index]];
1018
+ // TLC adds a successor's fingerprint to its set before it checks the invariants of the successor.
1274
1019
  runtime.isSeen = (state) => {
1275
1020
  const fingerprintState = getFingerprintState(state);
1276
- return findStateIndex(getStateHash(fingerprintState), fingerprintState) !== -1;
1021
+ const hash = getStateHash(fingerprintState);
1022
+ return (
1023
+ findStateIndex(seenStates, hash, fingerprintState) !== -1 ||
1024
+ isExplored(hash, fingerprintState) ||
1025
+ (unstoredFingerprint !== undefined && isSameState(unstoredFingerprint, fingerprintState))
1026
+ );
1027
+ };
1028
+ runtime.markExplored = (state) => {
1029
+ const fingerprintState = getFingerprintState(state);
1030
+ exploredTable ??= createStateTable(exploredFingerprintStates);
1031
+ markSeenState(exploredTable, getStateHash(fingerprintState), exploredStates.length);
1032
+ exploredStates.push(state);
1033
+ exploredFingerprintStates.push(fingerprintState);
1034
+ runtime.distinctStates++;
1277
1035
  };
1278
1036
  runtime.getBehavior = (state) => {
1279
1037
  const index = state === current.candidate ? -1 : states.indexOf(state);
1280
1038
  return index === -1 ? [...getPath(current.index), state] : getPath(index);
1281
1039
  };
1282
- runtime.getCurrentState = () => (current.index === -1 ? undefined : states[current.index]);
1040
+ runtime.getCurrentState = () =>
1041
+ current.rebuilt?.state ?? (current.index === -1 ? undefined : states[current.index]);
1283
1042
  runtime.setLivenessSource = (index) => {
1284
1043
  current.livenessSource = index ?? -1;
1285
1044
  };
@@ -1309,26 +1068,27 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1309
1068
  formatState(
1310
1069
  config.alias === undefined
1311
1070
  ? toRecord(state)
1312
- : evaluateAlias(config.alias, state, undefined),
1071
+ : search.evaluateAlias(config.alias, state, undefined, options.isTool ?? false),
1313
1072
  ),
1314
1073
  getText: () => formatState(toRecord(state)),
1315
1074
  });
1316
1075
 
1317
1076
  const visitInitialState = (state: Value[]) => {
1318
- canonicalizeState(state);
1319
1077
  runtime.generatedStates++;
1320
1078
  runtime.initialStates++;
1321
1079
  current.candidate = state;
1322
1080
  current.candidateLevel = 1;
1323
- const fingerprintState = getFingerprintState(state);
1324
- const hash = getStateHash(fingerprintState);
1325
1081
  const isInModel = search.satisfiesConstraints(state);
1082
+ // TLC fingerprints only a state in the model, which sorts its records in place.
1083
+ if (isInModel) canonicalizeState(state);
1084
+ const fingerprintState = isInModel ? getFingerprintState(state) : state;
1085
+ const hash = isInModel ? getStateHash(fingerprintState) : 0;
1326
1086
  if (isInModel) {
1327
1087
  search.trackStatePossible(state);
1328
1088
  fingerprintModelState(fingerprintState);
1329
1089
  state.forEach(markFingerprinted);
1330
1090
  }
1331
- const isSeen = isInModel && findStateIndex(hash, fingerprintState) !== -1;
1091
+ const isSeen = isInModel && findStateIndex(seenStates, hash, fingerprintState) !== -1;
1332
1092
  if (isSeen) return undefined;
1333
1093
  unstoredFingerprint = isInModel ? fingerprintState : undefined;
1334
1094
  if (isInModel) {
@@ -1338,32 +1098,56 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1338
1098
  stateWriter?.writeInitialState(getGraphState(state, 1));
1339
1099
  }
1340
1100
  if (options.isContinued) {
1341
- search.getViolatedInvariants(state).forEach((invariant) =>
1101
+ search.forEachViolatedInvariant(state, (invariant) =>
1342
1102
  reportContinuedViolation("invariant-violation", {
1343
1103
  name: invariant.name,
1344
- ...toTrace([{ action: undefined, state }], []),
1104
+ ...traces.toTrace([{ action: undefined, state }], []),
1345
1105
  }),
1346
1106
  );
1347
1107
  }
1348
1108
  const violated = options.isContinued ? undefined : search.findViolatedInvariant(state);
1349
1109
  if (violated) {
1350
- return reportViolation("invariant-violation", {
1351
- name: violated.name,
1352
- ...toTrace([{ action: undefined, state }], []),
1353
- });
1110
+ return reportViolation(
1111
+ "invariant-violation",
1112
+ { name: violated.name, ...traces.toTrace([{ action: undefined, state }], []) },
1113
+ getStepState,
1114
+ );
1354
1115
  }
1355
1116
  const failedPredicate = search.findFailedInitialPredicate(state);
1356
1117
  if (failedPredicate) {
1357
- return reportViolation("liveness-violation", {
1358
- name: failedPredicate.name,
1359
- ...toTrace([{ action: undefined, state }], []),
1360
- });
1118
+ return reportViolation(
1119
+ "liveness-violation",
1120
+ { name: failedPredicate.name, ...traces.toTrace([{ action: undefined, state }], []) },
1121
+ getStepState,
1122
+ );
1361
1123
  }
1362
1124
  if (!isInModel) return undefined;
1363
- markSeen(hash, states.length);
1125
+ markSeenState(seenStates, hash, states.length);
1364
1126
  addState(state, fingerprintState, -1, undefined);
1365
1127
  return undefined;
1366
1128
  };
1129
+ // Looks a successor up, where the constraints keep it in the model, as the search does before it
1130
+ // checks the successor.
1131
+ const lookUpSuccessor = (state: Value[], successor: Successor) => {
1132
+ const isStateInModel = search.satisfiesConstraints(successor.state, state);
1133
+ if (isStateInModel) search.trackStatePossible(successor.state);
1134
+ const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
1135
+ const fingerprintState = isInModel ? getFingerprintState(successor.state) : successor.state;
1136
+ const hash = isInModel ? getStateHash(fingerprintState) : 0;
1137
+ if (isInModel) {
1138
+ search.trackActionPossible(state, successor.state);
1139
+ fingerprintModelState(fingerprintState);
1140
+ successor.state.forEach(markFingerprinted);
1141
+ }
1142
+ const existing = isInModel ? findStateIndex(seenStates, hash, fingerprintState) : -1;
1143
+ return {
1144
+ fingerprintState,
1145
+ hash,
1146
+ isInModel,
1147
+ existing,
1148
+ isSeen: existing !== -1 || (isInModel && isExplored(hash, fingerprintState)),
1149
+ };
1150
+ };
1367
1151
  const visitSuccessor = (
1368
1152
  index: number,
1369
1153
  successor: Successor,
@@ -1376,27 +1160,16 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1376
1160
  current.candidate = successor.state;
1377
1161
  current.candidateLevel = depths[index] + 1;
1378
1162
  if (isCanonicalizedFirst) canonicalizeState(successor.state);
1379
- const fingerprintState = getFingerprintState(successor.state);
1380
- const hash = getStateHash(fingerprintState);
1381
- const foundIndex = findStateIndex(hash, fingerprintState);
1382
- const isStateInModel = search.satisfiesConstraints(successor.state, state);
1383
- if (isStateInModel) search.trackStatePossible(successor.state);
1384
- const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
1385
- if (isInModel) {
1386
- search.trackActionPossible(state, successor.state);
1387
- fingerprintModelState(fingerprintState);
1388
- successor.state.forEach(markFingerprinted);
1389
- }
1390
- const existing = isInModel ? foundIndex : -1;
1391
- if (source && isInModel) {
1163
+ const found = lookUpSuccessor(state, successor);
1164
+ if (source && found.isInModel) {
1392
1165
  stateWriter?.writeSuccessor(
1393
1166
  source,
1394
1167
  getGraphState(successor.state, depths[index] + 1),
1395
- existing !== -1,
1168
+ found.isSeen,
1396
1169
  action && getGraphAction(action),
1397
1170
  );
1398
1171
  }
1399
- if (source && !isInModel && options.dump?.constrained) {
1172
+ if (source && !found.isInModel && options.dump?.constrained) {
1400
1173
  const excluded = getGraphState(successor.state, depths[index] + 1);
1401
1174
  search
1402
1175
  .getExcludingConstraints(state, successor.state)
@@ -1409,33 +1182,45 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1409
1182
  ),
1410
1183
  );
1411
1184
  }
1412
- if (existing !== -1 && liveness) {
1413
- const stored = states[existing];
1185
+ if (found.existing !== -1 && liveness) {
1186
+ const stored = states[found.existing];
1414
1187
  const isStored = stored.every((value, position) => value === successor.state[position]);
1415
- liveSuccessors.push({ index: existing, state: isStored ? stored : successor.state });
1188
+ liveSuccessors.push({ index: found.existing, state: isStored ? stored : successor.state });
1416
1189
  }
1417
- const isNew = isInModel && existing === -1;
1190
+ if (found.isSeen && found.existing === -1 && liveness) {
1191
+ liveSuccessors.push({
1192
+ index: getPendingIndex(found.hash, found.fingerprintState),
1193
+ state: successor.state,
1194
+ });
1195
+ }
1196
+ const isNew = found.isInModel && !found.isSeen;
1418
1197
  if (isNew && liveness) liveSuccessors.push({ index: states.length, state: successor.state });
1419
- unstoredFingerprint = isNew ? fingerprintState : undefined;
1198
+ unstoredFingerprint = isNew ? found.fingerprintState : undefined;
1420
1199
  if (isNew) {
1421
1200
  countDistinctState(depths[index] + 1);
1422
1201
  newStateCount++;
1423
1202
  if (coverage) coverage.secondary[coveredNode]++;
1424
1203
  }
1425
- if (existing === -1) {
1204
+ if (!found.isSeen) {
1426
1205
  try {
1427
1206
  const violated = search.findViolatedInvariant(successor.state, state);
1428
- const violation = violated && { name: violated.name, ...getTrace(index, successor) };
1207
+ const violation = violated && {
1208
+ name: violated.name,
1209
+ ...traces.getTrace(index, successor, { isPrintedOnly: options.isContinued }),
1210
+ };
1429
1211
  if (violation && !options.isContinued) {
1430
1212
  return withOutDegrees(reportViolation("invariant-violation", violation));
1431
1213
  }
1432
1214
  if (violation) reportContinuedViolation("invariant-violation", violation);
1433
1215
  } catch (error) {
1434
1216
  if (isStackOverflow(error)) throw error;
1435
- const replay = captureOutput(() => replayNext(index));
1217
+ const behavior = traces.getTrace(index, successor, { isPrintedOnly: true });
1218
+ const replay = is174
1219
+ ? captureOutput(() => replayNext(index))
1220
+ : replayFailedNext(index, liveSuccessors);
1436
1221
  return createFailureResult(
1437
1222
  error,
1438
- appendTraceOutput(getFailedTrace(index, successor), replay.lines),
1223
+ appendTraceOutput(behavior, replay.lines),
1439
1224
  replay.result ?? { outDegrees: getFailureOutDegrees() },
1440
1225
  );
1441
1226
  }
@@ -1443,7 +1228,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1443
1228
  const violatedProperty = search.findViolatedActionProperty(state, successor.state);
1444
1229
  const propertyViolation = violatedProperty && {
1445
1230
  name: violatedProperty.name,
1446
- ...getTrace(index, successor),
1231
+ ...traces.getTrace(index, successor, { isPrintedOnly: options.isContinued }),
1447
1232
  };
1448
1233
  if (propertyViolation && !options.isContinued) {
1449
1234
  return withOutDegrees(reportViolation("liveness-violation", propertyViolation));
@@ -1452,8 +1237,12 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1452
1237
  if (!isNew) return undefined;
1453
1238
  if (coverage) countCoverageVariables(coverage, successor.state);
1454
1239
  if (!isCanonicalizedFirst) canonicalizeState(successor.state);
1455
- markSeen(hash, states.length);
1456
- addState(successor.state, fingerprintState, index, successor.action);
1240
+ markSeenState(seenStates, found.hash, states.length);
1241
+ if (pendingStates) {
1242
+ const pending = findStateIndex(pendingStates, found.hash, found.fingerprintState);
1243
+ if (pending !== -1) liveness?.storeState(-2 - pending, states.length);
1244
+ }
1245
+ addState(successor.state, found.fingerprintState, index, successor.action);
1457
1246
  runtime.queueSize++;
1458
1247
  return undefined;
1459
1248
  };
@@ -1466,6 +1255,57 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1466
1255
  const assumptionViolation = findViolatedAssumption();
1467
1256
  if (assumptionViolation) return createResult("assumption-violation", assumptionViolation);
1468
1257
  options.onProgress?.({ kind: "initial-states-started" });
1258
+ const typedChecks =
1259
+ !options.isContinued &&
1260
+ options.dump === undefined &&
1261
+ // A set of small integers on the tier is a 31-bit mask, which a lower bound could overflow.
1262
+ options.maxSetSize === undefined &&
1263
+ !hasPostconditions
1264
+ ? search.getTypedChecks(liveness?.solutions)
1265
+ : undefined;
1266
+ const typed =
1267
+ typedChecks &&
1268
+ runTypedSearch(environment, {
1269
+ ...typedChecks,
1270
+ isDeadlockChecked: config.checkDeadlock,
1271
+ isFingerprinted: !options.isFingerprintDistanceSkipped,
1272
+ livenessCheck: options.livenessCheck ?? "default",
1273
+ });
1274
+ if (typed && !typed.deadlock && !typed.violation && !typed.lasso) {
1275
+ for (let count = 2; count < typed.initialStates.generated; count *= 2) {
1276
+ reportInitialStatesProgress(count, options.onProgress);
1277
+ }
1278
+ options.onProgress?.({ kind: "initial-states-computed", initialStates: typed.initialStates });
1279
+ const statistics = {
1280
+ ...createResult("success"),
1281
+ generatedStates: typed.generatedStates,
1282
+ distinctStates: typed.distinctStates,
1283
+ queuedStates: 0,
1284
+ depth: typed.generatedStates === 0 ? 0 : Math.max(typed.depth, 1),
1285
+ initialStates: typed.initialStates,
1286
+ };
1287
+ if (liveness && options.livenessCheck !== "off") {
1288
+ options.onProgress?.({
1289
+ kind: "liveness-started",
1290
+ branches: liveness.branches,
1291
+ isComplete: true,
1292
+ states: liveness.branches * typed.distinctStates,
1293
+ statistics,
1294
+ });
1295
+ options.onProgress?.({ kind: "liveness-finished" });
1296
+ }
1297
+ return {
1298
+ ...statistics,
1299
+ outDegrees: typed.outDegrees,
1300
+ fingerprintDistance: options.isFingerprintDistanceSkipped
1301
+ ? undefined
1302
+ : getFingerprintDistance(
1303
+ typed.distinctStates,
1304
+ typed.generatedStates,
1305
+ typed.forEachFingerprintRun,
1306
+ ),
1307
+ };
1308
+ }
1469
1309
  if (spec.init !== undefined) {
1470
1310
  let overflowState: Value[] | undefined;
1471
1311
  const reportInitialFailure = (error: unknown, state: Value[]) => {
@@ -1473,7 +1313,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1473
1313
  return createFailureResult(
1474
1314
  error,
1475
1315
  { trace: [], traceOutput: replay.lines },
1476
- { initialState: state, ...replay.result, isInitial: true },
1316
+ { initialState: state, ...replay.result, phase: "initial" },
1477
1317
  );
1478
1318
  };
1479
1319
  try {
@@ -1500,9 +1340,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1500
1340
  (state) => {
1501
1341
  if (onInitialState(state)) throw STOP_WALK;
1502
1342
  },
1503
- (partial) => {
1504
- throw setExitCode(new TlaIllegalStateError([...partial]), EXIT_STATUS.error);
1505
- },
1343
+ rejectIncompleteInitialState,
1506
1344
  );
1507
1345
  } catch (error) {
1508
1346
  if (error !== STOP_WALK) throw error;
@@ -1515,21 +1353,36 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1515
1353
  }
1516
1354
  } catch (error) {
1517
1355
  if (error instanceof TlaIllegalStateError) {
1356
+ reportInitialStatesProgress(runtime.initialStates, options.onProgress);
1357
+ runtime.generatedStates++;
1358
+ runtime.initialStates++;
1359
+ const state = error.state.map((value) => value ?? createModelValue("null"));
1360
+ // Deviation from TLC: CounterExample holds a Java null for an unassigned variable and leaks a NullPointerException, where tla-ts binds the model value null.
1361
+ const checked = checkTracePostconditions(
1362
+ [{ action: undefined, label: undefined, state: toRecord(state) }],
1363
+ undefined,
1364
+ getStepState,
1365
+ );
1366
+ const postcondition = checked.unwitnessed ?? checked.postcondition;
1518
1367
  const illegal = createFailureResult(
1519
1368
  error,
1520
- { trace: [] },
1521
- { initialState: error.state.map((value) => value ?? createModelValue("null")) },
1369
+ { trace: [], traceOutput: checked.lines },
1370
+ { initialState: state },
1522
1371
  );
1523
1372
  return {
1524
1373
  ...illegal,
1525
- failure: illegal.failure && { ...illegal.failure, isWithoutStatistics: true },
1374
+ failure: illegal.failure && {
1375
+ ...illegal.failure,
1376
+ isWithoutStatistics: true,
1377
+ ...(postcondition && { postcondition }),
1378
+ },
1526
1379
  };
1527
1380
  }
1528
1381
  const replay = captureOutput(replayInit);
1529
1382
  return createFailureResult(
1530
1383
  error,
1531
1384
  { trace: [], traceOutput: replay.lines },
1532
- { ...replay.result, isInitial: true },
1385
+ { ...replay.result, phase: "initial" },
1533
1386
  );
1534
1387
  }
1535
1388
  }
@@ -1567,7 +1420,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1567
1420
  try {
1568
1421
  coverageActions.forEach((action) => {
1569
1422
  coveredNode = action.node;
1570
- walkCoveredSuccessors(action, state, (successor) => {
1423
+ walkCoveredSuccessors(coverage, action, state, environment, (successor) => {
1571
1424
  successorCount++;
1572
1425
  if (onSuccessor({ state: successor, action: action.name }, action)) throw STOP_WALK;
1573
1426
  });
@@ -1589,7 +1442,7 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1589
1442
  );
1590
1443
  }
1591
1444
  let isStopped = false;
1592
- return getSpecNextActions().reduce((count, action) => {
1445
+ return nextActions.reduce((count, action) => {
1593
1446
  if (isStopped) return count;
1594
1447
  return (
1595
1448
  count +
@@ -1608,9 +1461,10 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1608
1461
  );
1609
1462
  }, 0);
1610
1463
  };
1464
+ // Deviation from TLC: Worker#doNextCheckLiveness doesn't catch a FingerprintException from its rerun, so TLC prints the behavior without the failure.
1611
1465
  const getLiveCallStack = (index: number, liveSuccessors: LiveSuccessor[]) => {
1612
1466
  if (!liveness || is174) return undefined;
1613
- const replay = getReplayFailure((tracing) =>
1467
+ const replay = getReplayFailure(environment, (tracing) =>
1614
1468
  liveness.addState(index, states[index], liveSuccessors, tracing),
1615
1469
  );
1616
1470
  return replay?.callStack.length && !replay.fingerprint ? replay.callStack : undefined;
@@ -1621,33 +1475,103 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1621
1475
  return undefined;
1622
1476
  } catch (error) {
1623
1477
  if (!(error instanceof TlaEvaluationError)) throw error;
1478
+ // TLC fails to fingerprint an incomplete successor with an exception Worker#doNextCheckLiveness doesn't rerun for a call stack.
1479
+ if (error instanceof TlaIncompleteSuccessorError) return undefined;
1624
1480
  return getLiveCallStack(index, liveSuccessors);
1625
1481
  }
1626
1482
  };
1627
1483
  const replayFailedNext = (index: number, liveSuccessors: LiveSuccessor[]) => {
1628
1484
  const live = captureOutput(() => addFailedLiveState(index, liveSuccessors));
1629
1485
  if (live.result) {
1630
- const result = { callStack: live.result, fingerprint: undefined, isLiveCallStack: true };
1486
+ const result: FailureOptions = { phase: "behavior-graph", callStack: live.result };
1631
1487
  return { result, lines: live.lines };
1632
1488
  }
1633
1489
  const replay = captureOutput(() => replayNext(index));
1634
- return { result: replay.result, lines: [...live.lines, ...replay.lines] };
1490
+ const result: FailureOptions =
1491
+ replay.result ?? (is174 ? {} : { outDegrees: getFailureOutDegrees() });
1492
+ return { result, lines: [...live.lines, ...replay.lines] };
1635
1493
  };
1636
- const reportNextStateOverflow = (index: number) =>
1637
- createFailureResult(createStackOverflowError(), getStateTrace(index), { isNextState: true });
1494
+ const getNextFailureTrace = (index: number, counterExample?: CounterExampleOptions) =>
1495
+ checkFailedTrace(
1496
+ traces.getStateTrace(index, { isPrintedOnly: !counterExample }),
1497
+ counterExample,
1498
+ );
1499
+ const reportNextStateOverflow = (index: number, counterExample?: CounterExampleOptions) => {
1500
+ const checked = getNextFailureTrace(index, counterExample);
1501
+ return createFailureResult(
1502
+ createStackOverflowError(),
1503
+ checked.behavior,
1504
+ { phase: "next" },
1505
+ checked.postcondition,
1506
+ );
1507
+ };
1508
+ // Deviation from TLC: under -continue, TLC's Worker reports a state whose next-state relation failed as deadlocked, or else reports the failure twice as its replay fails again.
1509
+ // Deviation from TLC: under -continue, ModelChecker#doNextEvalFailed rethrows a failed invariant to Worker#doNextFailed, which reports it again with the code of its error.
1638
1510
  const reportNextStateFailure = (
1639
1511
  error: unknown,
1640
1512
  index: number,
1641
1513
  liveSuccessors: LiveSuccessor[],
1514
+ generated: number,
1642
1515
  ) => {
1643
- if (isStackOverflow(error)) return reportNextStateOverflow(index);
1516
+ // TLC's Worker goes on to find a state without successors deadlocked after it fails, which checks the postconditions.
1517
+ const counterExample =
1518
+ config.checkDeadlock && runtime.generatedStates === generated
1519
+ ? { isConsole: false }
1520
+ : undefined;
1521
+ if (isStackOverflow(error)) return reportNextStateOverflow(index, counterExample);
1522
+ const checked = getNextFailureTrace(index, counterExample);
1644
1523
  const replay = replayFailedNext(index, liveSuccessors);
1645
1524
  return createFailureResult(
1646
1525
  withNextStateExitCode(error),
1647
- appendTraceOutput(getStateTrace(index), replay.lines),
1648
- { isNextState: true, ...replay.result },
1526
+ appendTraceOutput(checked.behavior, replay.lines),
1527
+ { phase: "next", ...replay.result },
1528
+ checked.postcondition,
1649
1529
  );
1650
1530
  };
1531
+ const addLiveState = (
1532
+ index: number,
1533
+ liveSuccessors: LiveSuccessor[],
1534
+ source: GraphState | undefined,
1535
+ ) => {
1536
+ if (liveness && source && (is174 || options.dump?.stuttering)) {
1537
+ stateWriter?.writeStuttering(source);
1538
+ }
1539
+ const accepted = liveness?.addState(index, states[index], liveSuccessors);
1540
+ if (!liveness || !accepted) return undefined;
1541
+ // Deviation from TLC: under -continue, TLC's LiveCheck throws an InvariantViolatedException after it reports the property, which its Worker reports as unexpected.
1542
+ const steps = traces.getPathSteps(accepted);
1543
+ const properties = getViolatedProperties(
1544
+ liveness,
1545
+ steps.map((step) => step.state),
1546
+ steps.length - 1,
1547
+ );
1548
+ return reportViolation("property-violation", {
1549
+ name: properties[0],
1550
+ properties,
1551
+ ...traces.toTrace(steps, accepted, { known: 0 }),
1552
+ });
1553
+ };
1554
+ const addReportedLiveState = (
1555
+ index: number,
1556
+ liveSuccessors: LiveSuccessor[],
1557
+ source: GraphState | undefined,
1558
+ ) =>
1559
+ captureOutput(() => {
1560
+ try {
1561
+ return {
1562
+ additional: addLiveState(index, liveSuccessors, source)?.violation,
1563
+ isFailed: false,
1564
+ callStack: undefined,
1565
+ };
1566
+ } catch (error) {
1567
+ if (!(error instanceof TlaEvaluationError)) throw error;
1568
+ return {
1569
+ additional: undefined,
1570
+ isFailed: true,
1571
+ callStack: getLiveCallStack(index, liveSuccessors),
1572
+ };
1573
+ }
1574
+ });
1651
1575
  const expandState = (index: number, liveSuccessors: LiveSuccessor[]) => {
1652
1576
  const state = states[index];
1653
1577
  const source = stateWriter && getGraphState(state, depths[index]);
@@ -1669,80 +1593,70 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1669
1593
  outcome = reportNextStateOverflow(index);
1670
1594
  return true;
1671
1595
  }
1672
- const replay = is174
1673
- ? captureOutput(() => replayNext(index))
1674
- : replayFailedNext(index, liveSuccessors);
1675
1596
  if (is174 && error instanceof TlaEvaluationError && !isHeadedError(error)) {
1597
+ const replay = captureOutput(() => replayNext(index));
1676
1598
  outcome = createFailureResult(
1677
1599
  new TlaEvaluationError(`${getWrappedException(error)}${error.message}`, error),
1678
1600
  appendTraceOutput({ trace: [] }, replay.lines),
1679
- { isNextState: true, ...replay.result },
1601
+ { phase: "next", ...replay.result },
1680
1602
  );
1681
1603
  return true;
1682
1604
  }
1683
- const isTraceFailed = isUnfingerprintable(successor.state);
1684
- const traceFailure =
1685
- isTraceFailed && error instanceof TlaEvaluationError
1686
- ? getFailureMessage(
1687
- isEvalException(error)
1688
- ? new TlaEvaluationError(`${UNEXPECTED_EVAL_EXCEPTION}${error.message}`)
1689
- : error,
1690
- true,
1691
- )
1605
+ const traceError =
1606
+ error instanceof TlaEvaluationError && isUnfingerprintable(successor.state)
1607
+ ? error
1692
1608
  : undefined;
1693
- outcome = createFailureResult(
1694
- error,
1695
- appendTraceOutput(
1696
- traceFailure ? getStateTrace(index) : getFailedTrace(index, successor),
1697
- replay.lines,
1698
- ),
1699
- { isNextState: true, ...replay.result, traceFailure },
1700
- );
1609
+ const behavior = traceError
1610
+ ? traces.getStateTrace(index, { isPrintedOnly: true })
1611
+ : traces.getTrace(index, successor, { isPrintedOnly: true });
1612
+ const traceFailure =
1613
+ traceError &&
1614
+ getTraceFailure(
1615
+ traceError,
1616
+ captureOutput(() => {
1617
+ try {
1618
+ traces.findStepAction(index, state, successor.state, true);
1619
+ } catch (failed) {
1620
+ if (!(failed instanceof TlaEvaluationError)) throw failed;
1621
+ }
1622
+ }).lines,
1623
+ );
1624
+ const replay = is174
1625
+ ? captureOutput(() => replayNext(index))
1626
+ : replayFailedNext(index, liveSuccessors);
1627
+ outcome = createFailureResult(error, appendTraceOutput(behavior, replay.lines), {
1628
+ phase: "next",
1629
+ ...replay.result,
1630
+ traceFailure,
1631
+ });
1701
1632
  }
1702
1633
  return outcome !== undefined;
1703
1634
  });
1704
1635
  current.isExpanding = false;
1705
1636
  const result = outcome;
1706
1637
  if (result?.violation && !is174) {
1707
- const live = captureOutput(() => addFailedLiveState(index, liveSuccessors));
1638
+ const live = addReportedLiveState(index, liveSuccessors, source);
1708
1639
  return {
1709
1640
  ...result,
1710
1641
  violation: appendTraceOutput(result.violation, live.lines),
1711
- ...(live.result && { liveCallStack: live.result }),
1642
+ // TLC adds the state to the behavior graph before it reports the coverage.
1643
+ coverage: getCoverage(),
1644
+ ...(live.result.additional && { additionalViolation: live.result.additional }),
1645
+ ...(live.result.callStack && { liveCallStack: live.result.callStack }),
1712
1646
  };
1713
1647
  }
1714
1648
  if (result) return result;
1715
- const addLiveState = () => {
1716
- if (liveness && source && (is174 || options.dump?.stuttering)) {
1717
- stateWriter?.writeStuttering(source);
1718
- }
1719
- const accepted = liveness?.addState(index, state, liveSuccessors);
1720
- if (!liveness || !accepted) return undefined;
1721
- const steps = getPathSteps(accepted);
1722
- const properties = getViolatedProperties(
1723
- liveness,
1724
- steps.map((step) => step.state),
1725
- steps.length - 1,
1726
- );
1727
- return reportViolation("property-violation", {
1728
- name: properties[0],
1729
- properties,
1730
- ...toTrace(steps, accepted, { known: 0 }),
1731
- });
1732
- };
1733
1649
  if (successorCount === 0 && config.checkDeadlock) {
1734
- const deadlock = reportViolation("deadlock", { name: "deadlock", ...getStateTrace(index) });
1735
- const live = captureOutput(() => {
1736
- try {
1737
- return { additional: addLiveState()?.violation };
1738
- } catch (error) {
1739
- if (!(error instanceof TlaEvaluationError)) throw error;
1740
- return { isFailed: true, callStack: getLiveCallStack(index, liveSuccessors) };
1741
- }
1650
+ const deadlock = reportViolation("deadlock", {
1651
+ name: "deadlock",
1652
+ ...traces.getStateTrace(index),
1742
1653
  });
1743
- const reported = deadlock.violation
1744
- ? { ...deadlock, violation: appendTraceOutput(deadlock.violation, live.lines) }
1745
- : deadlock;
1654
+ const live = addReportedLiveState(index, liveSuccessors, source);
1655
+ const reported = {
1656
+ ...deadlock,
1657
+ violation: deadlock.violation && appendTraceOutput(deadlock.violation, live.lines),
1658
+ coverage: getCoverage(),
1659
+ };
1746
1660
  const counted = withOutDegrees(
1747
1661
  reported,
1748
1662
  live.result.isFailed ? getFailureOutDegrees() : getPartialOutDegrees(),
@@ -1752,26 +1666,24 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1752
1666
  return live.result.callStack ? { ...counted, liveCallStack: live.result.callStack } : counted;
1753
1667
  }
1754
1668
  try {
1755
- return addLiveState();
1669
+ return addLiveState(index, liveSuccessors, source);
1756
1670
  } catch (error) {
1757
1671
  if (is174 && error instanceof TlaEvaluationError) {
1758
- const unexpected = new TlaEvaluationError(
1759
- `${isEvalException(error) ? UNEXPECTED_EVAL_EXCEPTION : UNEXPECTED_EXCEPTION}${error.message}`,
1760
- );
1761
1672
  return createFailureResult(
1762
- setExitCode(unexpected, EXIT_STATUS.error),
1673
+ setExitCode(toUnexpectedError(error), EXIT_STATUS.error),
1763
1674
  { trace: [] },
1764
1675
  { outDegrees: getFailureOutDegrees() },
1765
1676
  );
1766
1677
  }
1767
- const replay = getReplayFailure((tracing) =>
1678
+ const replay = getReplayFailure(environment, (tracing) =>
1768
1679
  liveness?.addState(index, state, liveSuccessors, tracing),
1769
1680
  );
1770
- return createFailureResult(error, getStateTrace(index), {
1681
+ const behavior = traces.getStateTrace(index, { isPrintedOnly: true });
1682
+ const replayed = captureOutput(() => replayNext(index));
1683
+ return createFailureResult(error, appendTraceOutput(behavior, replayed.lines), {
1771
1684
  outDegrees: getFailureOutDegrees(),
1772
1685
  callStack: replay?.callStack.length ? replay.callStack : undefined,
1773
- isNextState: true,
1774
- isCallStackFirst: true,
1686
+ phase: "liveness",
1775
1687
  });
1776
1688
  }
1777
1689
  };
@@ -1792,11 +1704,21 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1792
1704
  text: `The stuttering counterexample above may be caused by the absence of a fairness constraint in the behavior specification ${name} defined at ${formatRange(range)}. To rule out such counterexamples, conjoin a suitable fairness constraint to ${name} ${book}`,
1793
1705
  };
1794
1706
  };
1707
+ const toLivenessFailure = (error: TlaEvaluationError) =>
1708
+ setExitCode(toUnexpectedError(error), EXIT_STATUS.abort);
1709
+ const getLassoSteps = (path: number[]) => {
1710
+ try {
1711
+ return traces.getPathSteps(path);
1712
+ } catch (error) {
1713
+ if (!(error instanceof TlaEvaluationError)) throw error;
1714
+ throw toLivenessFailure(error);
1715
+ }
1716
+ };
1795
1717
  const reportLasso = (checker: LivenessChecker, lasso: Lasso) => {
1796
1718
  const path = [...lasso.prefix, ...lasso.cycle];
1797
1719
  const loopStart = lasso.prefix.length;
1798
- const steps = getPathSteps(path, loopStart);
1799
- const trace = toTrace(steps, path, { loopStart, known: 0 }).trace;
1720
+ const steps = getLassoSteps(path);
1721
+ const trace = traces.toTrace(steps, path, { loopStart, known: 0 }).trace;
1800
1722
  const properties = getViolatedProperties(
1801
1723
  checker,
1802
1724
  steps.map((step) => step.state),
@@ -1805,11 +1727,28 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1805
1727
  const cycleStart = path[loopStart];
1806
1728
  const cycleEnd = path[path.length - 1];
1807
1729
  const lastState = steps[steps.length - 1].state;
1808
- const loop =
1809
- cycleStart === cycleEnd
1810
- ? { result: undefined, lines: [] }
1811
- : captureOutput(() => findStepAction(cycleEnd, lastState, states[cycleStart], false));
1812
- const isStutteringWarned = cycleStart === cycleEnd && lasso.isCycleConstrained;
1730
+ const isStuttering = cycleStart === cycleEnd;
1731
+ const loop = isStuttering
1732
+ ? { result: undefined, lines: [] }
1733
+ : captureOutput(() => traces.findStepAction(cycleEnd, lastState, states[cycleStart], false));
1734
+ const back =
1735
+ isStuttering || loop.result
1736
+ ? undefined
1737
+ : traces.findSuccessorWithFingerprint(lastState, cycleEnd, cycleStart);
1738
+ if (!isStuttering && !loop.result && !back) {
1739
+ options.onProgress?.({
1740
+ kind: "violation",
1741
+ status: "property-violation",
1742
+ violation: {
1743
+ name: properties[0],
1744
+ properties,
1745
+ trace,
1746
+ traceOutput: loop.lines,
1747
+ loopStart: undefined,
1748
+ },
1749
+ });
1750
+ throw toLivenessFailure(new TlaEvaluationError(NEXT_RECOVERY_FAILURE));
1751
+ }
1813
1752
  return reportViolation(
1814
1753
  "liveness-violation",
1815
1754
  {
@@ -1819,62 +1758,171 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1819
1758
  traceOutput: loop.lines,
1820
1759
  loopStart,
1821
1760
  loopLabel: loop.result && getActionLabel(loop.result, options.version),
1822
- warning: isStutteringWarned ? getStutteringWarning() : undefined,
1761
+ warning: isStuttering && lasso.isCycleConstrained ? getStutteringWarning() : undefined,
1823
1762
  },
1763
+ getStepState,
1824
1764
  () =>
1825
- cycleStart === cycleEnd
1765
+ isStuttering
1826
1766
  ? getStepAction(trace[trace.length - 1])
1827
1767
  : loop.result
1828
1768
  ? toActionValue(loop.result)
1829
- : createActionRecord(findSuccessorWithFingerprint(lastState, cycleStart)?.action),
1769
+ : createActionRecord(back?.action),
1830
1770
  );
1831
1771
  };
1832
1772
  const isPeriodic = liveness !== undefined && (options.livenessCheck ?? "default") === "default";
1833
1773
  const startedAt = performance.now();
1834
1774
  const periodic = {
1835
1775
  at: startedAt + PERIODIC_START,
1836
- size: 1,
1776
+ checkedCounts: liveness?.getStateCounts().map(() => 1) ?? [],
1837
1777
  time: 0,
1838
1778
  coverageCount: Math.trunc(options.coverage ?? 0),
1839
1779
  };
1840
- const findPeriodicViolation = (expanded: number) => {
1780
+ const getGraphStates = (checker: LivenessChecker) =>
1781
+ checker.getStateCounts().reduce((sum, count) => sum + count, 0);
1782
+ const findPeriodicViolation = (checker: LivenessChecker) => {
1841
1783
  const now = performance.now();
1842
- const isGrown = (expanded - periodic.size) / periodic.size > LIVENESS_GROWTH;
1784
+ const counts = checker.getStateCounts();
1785
+ const isGrown = counts.some(
1786
+ (count, branch) =>
1787
+ (count - periodic.checkedCounts[branch]) / periodic.checkedCounts[branch] > LIVENESS_GROWTH,
1788
+ );
1843
1789
  if (!isGrown || periodic.time > (now - startedAt) * LIVENESS_RATIO) return undefined;
1844
- periodic.size = expanded;
1845
- if (!liveness) return undefined;
1790
+ periodic.checkedCounts = counts;
1846
1791
  options.onProgress?.({
1847
1792
  kind: "liveness-started",
1848
- branches: liveness.branches,
1793
+ branches: checker.branches,
1849
1794
  isComplete: false,
1850
- states: expanded,
1795
+ states: getGraphStates(checker),
1851
1796
  statistics: createResult("success"),
1852
1797
  });
1853
- const lasso = liveness.findViolation();
1798
+ const lasso = checker.findViolation();
1854
1799
  if (!lasso) options.onProgress?.({ kind: "liveness-finished" });
1855
1800
  periodic.time += performance.now() - now;
1856
1801
  return lasso;
1857
1802
  };
1858
- for (let index = 0; index < states.length && !runtime.isStopped; index++) {
1803
+ const adoptTypedSearch = (searched: TypedResult) => {
1804
+ runtime.generatedStates = searched.generatedStates;
1805
+ runtime.distinctStates = searched.distinctStates;
1806
+ runtime.queueSize = searched.queuedStates;
1807
+ runtime.diameter = searched.depth;
1808
+ searchDepth = searched.depth;
1809
+ outDegrees.splice(0, outDegrees.length, ...searched.outDegrees);
1810
+ newStateCount = 0;
1811
+ };
1812
+ // The tier found a state without successors, or a successor that violates an invariant or an
1813
+ // action property. The interpreter rebuilds the tier's path to it and reports it, as it would after
1814
+ // its own search.
1815
+ const path = typed?.deadlock ?? typed?.violation;
1816
+ const initialIndex = path ? states.findIndex((state) => path.isPathState(0, state)) : -1;
1817
+ if (typed && path && initialIndex !== -1) {
1818
+ const steps: { successor: Successor; action: SpecAction | undefined }[] = [];
1819
+ const getLastState = () => steps.at(-1)?.successor.state ?? states[initialIndex];
1820
+ for (let position = 1; position === steps.length + 1 && position < path.length; position++) {
1821
+ // The interpreter expands only the states it stores, which it has canonicalized.
1822
+ canonicalizeState(getLastState());
1823
+ forEachActionSuccessor(getLastState(), undefined, (successor, action) => {
1824
+ if (!path.isPathState(position, successor.state)) return false;
1825
+ steps.push({ successor, action });
1826
+ return true;
1827
+ });
1828
+ }
1829
+ const isRebuilt = steps.length === path.length - 1;
1830
+ const violating = typed.violation && isRebuilt ? steps.pop() : undefined;
1831
+ if (violating && isCanonicalizedFirst) canonicalizeState(violating.successor.state);
1832
+ const violatedInvariant =
1833
+ violating && search.findViolatedInvariant(violating.successor.state, getLastState());
1834
+ const violatedProperty =
1835
+ violating &&
1836
+ !violatedInvariant &&
1837
+ search.findViolatedActionProperty(getLastState(), violating.successor.state);
1838
+ const violated = violatedInvariant ?? violatedProperty;
1839
+ const isDeadlocked =
1840
+ typed.deadlock !== undefined &&
1841
+ isRebuilt &&
1842
+ forEachActionSuccessor(getLastState(), undefined, () => true) === 0;
1843
+ if (isDeadlocked || violated) {
1844
+ const parent = { index: initialIndex };
1845
+ for (const step of steps) {
1846
+ visitSuccessor(parent.index, step.successor, [], undefined, step.action);
1847
+ parent.index = states.length - 1;
1848
+ }
1849
+ adoptTypedSearch(typed);
1850
+ Object.assign(current, { index: parent.index, candidate: undefined, isExpanding: true });
1851
+ if (violating && violated) {
1852
+ lookUpSuccessor(states[parent.index], violating.successor);
1853
+ current.candidate = violating.successor.state;
1854
+ current.candidateLevel = depths[parent.index] + 1;
1855
+ return withOutDegrees(
1856
+ reportViolation(violatedInvariant ? "invariant-violation" : "liveness-violation", {
1857
+ name: violated.name,
1858
+ ...traces.getTrace(parent.index, violating.successor),
1859
+ }),
1860
+ );
1861
+ }
1862
+ const result = expandState(parent.index, []);
1863
+ if (result) return result;
1864
+ }
1865
+ }
1866
+ // The tier found a behavior that violates a temporal property after its whole search. The
1867
+ // interpreter stores the paths to the lasso's states and reports it, as it would after its own.
1868
+ const lassoSteps = new Map<number, { successor: Successor; action: SpecAction | undefined }>();
1869
+ for (const entry of typed?.lasso?.states ?? []) {
1870
+ const initial = entry.parent === -1 ? states.find(entry.isState) : undefined;
1871
+ if (initial) {
1872
+ lassoSteps.set(entry.index, {
1873
+ successor: { state: initial, action: undefined },
1874
+ action: undefined,
1875
+ });
1876
+ }
1877
+ const parent = lassoSteps.get(entry.parent)?.successor.state;
1878
+ if (!parent) continue;
1879
+ // The interpreter expands only the states it stores, which it has canonicalized.
1880
+ canonicalizeState(parent);
1881
+ forEachActionSuccessor(parent, undefined, (successor, action) => {
1882
+ if (!entry.isState(successor.state)) return false;
1883
+ lassoSteps.set(entry.index, { successor, action });
1884
+ return true;
1885
+ });
1886
+ }
1887
+ const lassoIndexes = new Map<number, number>();
1888
+ const typedLasso =
1889
+ typed?.lasso && lassoSteps.size === typed.lasso.states.length ? typed.lasso : undefined;
1890
+ typedLasso?.states.forEach((entry) => {
1891
+ const step = lassoSteps.get(entry.index);
1892
+ const parent = lassoIndexes.get(entry.parent);
1893
+ if (step && parent !== undefined)
1894
+ visitSuccessor(parent, step.successor, [], undefined, step.action);
1895
+ lassoIndexes.set(
1896
+ entry.index,
1897
+ parent === undefined ? states.findIndex(entry.isState) : states.length - 1,
1898
+ );
1899
+ });
1900
+ if (typed && typedLasso) adoptTypedSearch(typed);
1901
+ for (
1902
+ let index = typedLasso ? states.length : 0;
1903
+ index < states.length && !runtime.isStopped;
1904
+ index++
1905
+ ) {
1859
1906
  current.index = index;
1860
1907
  current.candidate = undefined;
1861
1908
  runtime.queueSize = states.length - index - 1;
1862
1909
  current.isExpanding = true;
1863
1910
  const liveSuccessors: LiveSuccessor[] = [];
1911
+ const generated = runtime.generatedStates;
1864
1912
  try {
1865
1913
  outcome = expandState(index, liveSuccessors);
1866
1914
  } catch (error) {
1867
1915
  outcome =
1868
1916
  error instanceof TlaIncompleteSuccessorError
1869
- ? reportIncompleteSuccessor(index, error)
1870
- : reportNextStateFailure(error, index, liveSuccessors);
1917
+ ? reportIncompleteSuccessor(index, error, liveSuccessors)
1918
+ : reportNextStateFailure(error, index, liveSuccessors, generated);
1871
1919
  }
1872
1920
  if (outcome) return outcome;
1873
1921
  outDegrees[getOutDegreeBucket()]++;
1874
1922
  newStateCount = 0;
1875
1923
  if ((isPeriodic || options.onProgress) && performance.now() >= periodic.at) {
1876
1924
  periodic.at = performance.now() + PROGRESS_INTERVAL;
1877
- const lasso = isPeriodic ? findPeriodicViolation(index + 1) : undefined;
1925
+ const lasso = isPeriodic && liveness ? findPeriodicViolation(liveness) : undefined;
1878
1926
  if (liveness && lasso) return reportLasso(liveness, lasso);
1879
1927
  const isCoverageDue = options.coverage !== undefined && periodic.coverageCount === 0;
1880
1928
  periodic.coverageCount = isCoverageDue
@@ -1896,11 +1944,21 @@ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefine
1896
1944
  kind: "liveness-started",
1897
1945
  branches: finalLiveness.branches,
1898
1946
  isComplete: true,
1899
- states: runtime.distinctStates,
1947
+ states: typedLasso
1948
+ ? finalLiveness.branches * runtime.distinctStates
1949
+ : getGraphStates(finalLiveness),
1900
1950
  statistics: createResult("success"),
1901
1951
  });
1902
1952
  }
1903
- const lasso = finalLiveness?.findViolation();
1953
+ const getLassoIndexes = (indexes: number[]) =>
1954
+ indexes.map((index) => lassoIndexes.get(index) ?? -1);
1955
+ const lasso = typedLasso
1956
+ ? {
1957
+ prefix: getLassoIndexes(typedLasso.prefix),
1958
+ cycle: getLassoIndexes(typedLasso.cycle),
1959
+ isCycleConstrained: typedLasso.isCycleConstrained,
1960
+ }
1961
+ : finalLiveness?.findViolation();
1904
1962
  if (finalLiveness && lasso) return reportLasso(finalLiveness, lasso);
1905
1963
 
1906
1964
  if (finalLiveness) options.onProgress?.({ kind: "liveness-finished" });