tla-ts 0.0.9 → 0.0.10-dev.06b481ee0

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