tla-ts 0.0.9 → 0.0.10

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 (390) hide show
  1. package/README.md +29 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +28 -28
  5. package/dist/deciders.js +43 -43
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +72 -10
  8. package/dist/index.d.ts +72 -10
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +116 -36
  15. package/dist/prove.js +116 -36
  16. package/dist/run.cjs +143 -31
  17. package/dist/run.js +143 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +128 -103
  21. package/dist/transfer.js +128 -103
  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 +7 -21
  26. package/src/bags.ts +99 -99
  27. package/src/builtins.ts +44 -75
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check.ts +576 -300
  30. package/src/cli/options.ts +11 -6
  31. package/src/cli/run.ts +2 -2
  32. package/src/cli/runtime-invariants.ts +135 -0
  33. package/src/cli/shared.ts +20 -9
  34. package/src/cli/tlapm.ts +0 -12
  35. package/src/cli/tlc-arguments.ts +646 -0
  36. package/src/cli/tlc-usage.ts +362 -0
  37. package/src/cli/tlc.ts +538 -220
  38. package/src/cli/typescript.ts +23 -0
  39. package/src/cli/xml-exporter.ts +4 -16
  40. package/src/cli.ts +0 -1
  41. package/src/codegen.ts +191 -64
  42. package/src/config.ts +140 -109
  43. package/src/coverage.ts +837 -0
  44. package/src/dependencies.ts +6 -40
  45. package/src/dfid.ts +618 -0
  46. package/src/environment.ts +240 -118
  47. package/src/errors.ts +70 -55
  48. package/src/evaluate.ts +630 -297
  49. package/src/exit-codes.ts +37 -3
  50. package/src/fingerprints.ts +10 -10
  51. package/src/index.ts +3 -0
  52. package/src/instances.ts +79 -11
  53. package/src/java-overrides.ts +2 -12
  54. package/src/json-reader.ts +456 -0
  55. package/src/json.ts +262 -139
  56. package/src/levels.ts +2 -3
  57. package/src/lexer.ts +17 -26
  58. package/src/liveness-checker.ts +10 -18
  59. package/src/liveness.ts +121 -49
  60. package/src/obligations/action.ts +4 -28
  61. package/src/obligations/anonymize.ts +84 -80
  62. package/src/obligations/equality.ts +1 -1
  63. package/src/obligations/expression.ts +2 -19
  64. package/src/obligations/format.ts +1 -9
  65. package/src/obligations/generate.ts +1 -11
  66. package/src/obligations/index.ts +0 -11
  67. package/src/obligations/levels.ts +4 -8
  68. package/src/obligations/module.ts +1 -15
  69. package/src/obligations/normalize.ts +5 -24
  70. package/src/obligations/operators.ts +1 -2
  71. package/src/obligations/pragma.ts +1 -10
  72. package/src/obligations/printer.ts +47 -46
  73. package/src/obligations/proof.ts +1 -5
  74. package/src/obligations/regroup.ts +1 -4
  75. package/src/obligations/simplify.ts +3 -14
  76. package/src/obligations/source.ts +1 -21
  77. package/src/obligations/subexpression.ts +5 -11
  78. package/src/obligations/substitution.ts +1 -3
  79. package/src/obligations/temporal.ts +8 -14
  80. package/src/obligations/tuples.ts +3 -9
  81. package/src/parallel-worker.ts +29 -39
  82. package/src/parallel.ts +29 -13
  83. package/src/parser.ts +436 -90
  84. package/src/pcal/ast.ts +7 -28
  85. package/src/pcal/parse.ts +11 -39
  86. package/src/pcal/tokenize.ts +4 -20
  87. package/src/pcal/translate.ts +10 -42
  88. package/src/pcal/validate.ts +3 -21
  89. package/src/pretty-print.ts +1 -2
  90. package/src/prover/decide-pool.ts +5 -10
  91. package/src/prover/deciders.ts +0 -4
  92. package/src/prover/first-order.ts +0 -11
  93. package/src/prover/isabelle/decide.ts +0 -6
  94. package/src/prover/isabelle/encode.ts +11 -23
  95. package/src/prover/isabelle/isar/inner-syntax.ts +108 -114
  96. package/src/prover/isabelle/isar/method.ts +25 -38
  97. package/src/prover/isabelle/isar/proof.ts +1 -10
  98. package/src/prover/isabelle/isar/statement.ts +1 -6
  99. package/src/prover/isabelle/isar/theory.ts +15 -26
  100. package/src/prover/isabelle/isar/type-check.ts +11 -25
  101. package/src/prover/isabelle/provers/blast/blast.ts +10 -41
  102. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  103. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  104. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  105. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  106. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  107. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  108. package/src/prover/isabelle/provers/classical.ts +14 -42
  109. package/src/prover/isabelle/provers/hypsubst.ts +11 -25
  110. package/src/prover/isabelle/pure/bicompose.ts +16 -13
  111. package/src/prover/isabelle/pure/consts.ts +1 -7
  112. package/src/prover/isabelle/pure/conv.ts +1 -9
  113. package/src/prover/isabelle/pure/drule.ts +24 -40
  114. package/src/prover/isabelle/pure/envir.ts +3 -52
  115. package/src/prover/isabelle/pure/goal.ts +1 -7
  116. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  117. package/src/prover/isabelle/pure/list.ts +0 -3
  118. package/src/prover/isabelle/pure/logic.ts +1 -14
  119. package/src/prover/isabelle/pure/name.ts +2 -9
  120. package/src/prover/isabelle/pure/net.ts +3 -59
  121. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  122. package/src/prover/isabelle/pure/pattern.ts +2 -19
  123. package/src/prover/isabelle/pure/raw-simplifier.ts +13 -49
  124. package/src/prover/isabelle/pure/rewriter.ts +26 -58
  125. package/src/prover/isabelle/pure/search.ts +3 -10
  126. package/src/prover/isabelle/pure/seq.ts +1 -10
  127. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  128. package/src/prover/isabelle/pure/table.ts +1 -31
  129. package/src/prover/isabelle/pure/tactic.ts +12 -22
  130. package/src/prover/isabelle/pure/tactical.ts +6 -12
  131. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  132. package/src/prover/isabelle/pure/term.ts +2 -43
  133. package/src/prover/isabelle/pure/thm.ts +13 -36
  134. package/src/prover/isabelle/pure/type.ts +2 -15
  135. package/src/prover/isabelle/pure/unify.ts +20 -30
  136. package/src/prover/isabelle/pure/variable.ts +3 -7
  137. package/src/prover/isabelle/tla/classical-setup.ts +9 -19
  138. package/src/prover/isabelle/tla/context.ts +8 -16
  139. package/src/prover/isabelle/tla/logic.ts +4 -11
  140. package/src/prover/isabelle/tla/simpdata.ts +46 -34
  141. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  142. package/src/prover/ocaml.ts +0 -6
  143. package/src/prover/prep/action.ts +4 -36
  144. package/src/prover/prep/enabled-axioms.ts +12 -19
  145. package/src/prover/prep/fingerprint.ts +0 -16
  146. package/src/prover/prep/level-comparison.ts +8 -12
  147. package/src/prover/prep/md5.ts +0 -2
  148. package/src/prover/prep/methods.ts +9 -36
  149. package/src/prover/prep/normalize.ts +4 -28
  150. package/src/prover/prove-worker.ts +0 -2
  151. package/src/prover/prove.ts +0 -36
  152. package/src/prover/ptl/decide.ts +7 -12
  153. package/src/prover/ptl/encode.ts +14 -36
  154. package/src/prover/ptl/sat.ts +24 -32
  155. package/src/prover/ptl/tableau.ts +12 -26
  156. package/src/prover/smt/axioms.ts +0 -7
  157. package/src/prover/smt/context.ts +19 -26
  158. package/src/prover/smt/data.ts +51 -54
  159. package/src/prover/smt/encode.ts +14 -35
  160. package/src/prover/smt/extensionality.ts +0 -10
  161. package/src/prover/smt/flatten.ts +3 -22
  162. package/src/prover/smt/format.ts +5 -10
  163. package/src/prover/smt/instances.ts +0 -10
  164. package/src/prover/smt/rewrite.ts +66 -101
  165. package/src/prover/smt/solver/act-cache.ts +0 -15
  166. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  167. package/src/prover/smt/solver/array.ts +1 -3
  168. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  169. package/src/prover/smt/solver/ast-lt.ts +1 -11
  170. package/src/prover/smt/solver/ast-util.ts +1 -6
  171. package/src/prover/smt/solver/ast.ts +1 -143
  172. package/src/prover/smt/solver/auf-solver.ts +6 -39
  173. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  174. package/src/prover/smt/solver/cg-table.ts +1 -18
  175. package/src/prover/smt/solver/clause.ts +1 -27
  176. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  177. package/src/prover/smt/solver/context.ts +4 -61
  178. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  179. package/src/prover/smt/solver/der.ts +2 -21
  180. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  181. package/src/prover/smt/solver/e-matching.ts +3 -34
  182. package/src/prover/smt/solver/enode.ts +1 -21
  183. package/src/prover/smt/solver/expr-ref.ts +1 -5
  184. package/src/prover/smt/solver/expr-safe-replace.ts +0 -5
  185. package/src/prover/smt/solver/fingerprints.ts +1 -12
  186. package/src/prover/smt/solver/flat-literals.ts +1 -9
  187. package/src/prover/smt/solver/goal.ts +2 -14
  188. package/src/prover/smt/solver/hash.ts +0 -8
  189. package/src/prover/smt/solver/hashtable.ts +1 -12
  190. package/src/prover/smt/solver/internalizer.ts +6 -98
  191. package/src/prover/smt/solver/lbool.ts +1 -2
  192. package/src/prover/smt/solver/literal.ts +0 -3
  193. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  194. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  195. package/src/prover/smt/solver/lp/containers.ts +12 -30
  196. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  197. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  198. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  199. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  200. package/src/prover/smt/solver/lp/dioph-eq.ts +12 -98
  201. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  202. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  203. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  204. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  205. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  206. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  207. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  208. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  209. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  210. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  211. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  212. package/src/prover/smt/solver/lp/nex.ts +1 -6
  213. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  214. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  215. package/src/prover/smt/solver/lp/nla-core.ts +35 -130
  216. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  217. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  218. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  220. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  221. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  222. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  223. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  224. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  225. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  226. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  227. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  228. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  229. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  230. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  231. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  232. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  233. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  234. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  235. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  236. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  237. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  238. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  239. package/src/prover/smt/solver/mam-compiler.ts +14 -56
  240. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  241. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  242. package/src/prover/smt/solver/model-checker.ts +2 -36
  243. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  244. package/src/prover/smt/solver/model-finder.ts +3 -15
  245. package/src/prover/smt/solver/model-generator.ts +1 -12
  246. package/src/prover/smt/solver/model-macro-solver.ts +12 -69
  247. package/src/prover/smt/solver/nlsat/algebraic.ts +55 -151
  248. package/src/prover/smt/solver/nlsat/atoms.ts +5 -19
  249. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  250. package/src/prover/smt/solver/nlsat/explain.ts +3 -47
  251. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  252. package/src/prover/smt/solver/nlsat/levelwise.ts +48 -129
  253. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  254. package/src/prover/smt/solver/nlsat/polynomial.ts +17 -156
  255. package/src/prover/smt/solver/nlsat/solver.ts +7 -67
  256. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  257. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -44
  258. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  259. package/src/prover/smt/solver/nnf.ts +3 -38
  260. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  261. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  262. package/src/prover/smt/solver/propagate-values.ts +1 -10
  263. package/src/prover/smt/solver/proto-model.ts +3 -48
  264. package/src/prover/smt/solver/pull-quant.ts +1 -12
  265. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  266. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  267. package/src/prover/smt/solver/qe-lite.ts +3 -33
  268. package/src/prover/smt/solver/qi-queue.ts +1 -16
  269. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  270. package/src/prover/smt/solver/quantifier-analyzer.ts +17 -37
  271. package/src/prover/smt/solver/quantifier-manager.ts +1 -8
  272. package/src/prover/smt/solver/random-gen.ts +1 -2
  273. package/src/prover/smt/solver/rational.ts +1 -8
  274. package/src/prover/smt/solver/ref-vector.ts +1 -6
  275. package/src/prover/smt/solver/relevancy.ts +2 -15
  276. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  277. package/src/prover/smt/solver/rewriter.ts +3 -85
  278. package/src/prover/smt/solver/rlimit.ts +2 -20
  279. package/src/prover/smt/solver/smtlib-parser.ts +2 -37
  280. package/src/prover/smt/solver/solver.ts +23 -34
  281. package/src/prover/smt/solver/sort.ts +1 -5
  282. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  283. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  284. package/src/prover/smt/solver/theory-lra-bounds.ts +0 -5
  285. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  286. package/src/prover/smt/solver/theory-lra-internalize.ts +1 -27
  287. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  288. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  289. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  290. package/src/prover/smt/solver/theory-lra.ts +1 -8
  291. package/src/prover/smt/solver/var-subst.ts +2 -26
  292. package/src/prover/smt/table.ts +0 -8
  293. package/src/prover/tlapm/cache.ts +20 -25
  294. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  295. package/src/prover/tlapm/tlapm.ts +12 -17
  296. package/src/prover/verdict.ts +0 -2
  297. package/src/prover/zenon/check/check.ts +0 -9
  298. package/src/prover/zenon/check/definitions.ts +5 -15
  299. package/src/prover/zenon/check/equality.ts +0 -8
  300. package/src/prover/zenon/check/functions.ts +0 -4
  301. package/src/prover/zenon/check/keys.ts +0 -7
  302. package/src/prover/zenon/check/propositional.ts +0 -3
  303. package/src/prover/zenon/check/records.ts +0 -5
  304. package/src/prover/zenon/check/relations.ts +0 -13
  305. package/src/prover/zenon/check/rewrites.ts +0 -6
  306. package/src/prover/zenon/check/sets.ts +0 -3
  307. package/src/prover/zenon/check/terms.ts +0 -17
  308. package/src/prover/zenon/check/tla.ts +0 -6
  309. package/src/prover/zenon/decide.ts +0 -12
  310. package/src/prover/zenon/encode.ts +1 -8
  311. package/src/prover/zenon/eqrel.ts +0 -13
  312. package/src/prover/zenon/equality-rules.ts +0 -4
  313. package/src/prover/zenon/expr.ts +1 -26
  314. package/src/prover/zenon/index-table.ts +17 -38
  315. package/src/prover/zenon/isar-case.ts +9 -19
  316. package/src/prover/zenon/isar.ts +1 -29
  317. package/src/prover/zenon/limits.ts +0 -4
  318. package/src/prover/zenon/llproof.ts +0 -9
  319. package/src/prover/zenon/mltoll.ts +54 -76
  320. package/src/prover/zenon/node.ts +1 -11
  321. package/src/prover/zenon/ocaml.ts +1 -17
  322. package/src/prover/zenon/parse.ts +2 -7
  323. package/src/prover/zenon/phrase.ts +1 -11
  324. package/src/prover/zenon/proof.ts +0 -9
  325. package/src/prover/zenon/propositional-rules.ts +0 -5
  326. package/src/prover/zenon/rules.ts +2 -6
  327. package/src/prover/zenon/search.ts +1 -17
  328. package/src/prover/zenon/tla/functions.ts +57 -29
  329. package/src/prover/zenon/tla/llproof.ts +63 -70
  330. package/src/prover/zenon/tla/records.ts +56 -27
  331. package/src/prover/zenon/tla/rewrites.ts +12 -19
  332. package/src/prover/zenon/tla/sets.ts +68 -39
  333. package/src/prover/zenon/tla/terms.ts +0 -6
  334. package/src/prover/zenon/tla/tla.ts +59 -58
  335. package/src/randomization.ts +84 -35
  336. package/src/resolve.ts +18 -60
  337. package/src/runtime.ts +11 -4
  338. package/src/sany/builtins.ts +3 -4
  339. package/src/sany/generator.ts +119 -169
  340. package/src/sany/levels.ts +6 -30
  341. package/src/sany/lexer.ts +7 -23
  342. package/src/sany/linter.ts +1 -8
  343. package/src/sany/modules.ts +1 -5
  344. package/src/sany/nodes.ts +0 -31
  345. package/src/sany/parse-error.ts +39 -117
  346. package/src/sany/report.ts +29 -63
  347. package/src/sany/selectors.ts +15 -39
  348. package/src/sany/source.ts +1 -17
  349. package/src/sany/xml.ts +13 -63
  350. package/src/search.ts +494 -154
  351. package/src/simulate.ts +694 -0
  352. package/src/spec-description.ts +166 -48
  353. package/src/standard-definitions.ts +2 -3
  354. package/src/standard-modules.ts +264 -68
  355. package/src/state-graph.ts +51 -18
  356. package/src/subexpressions.ts +31 -5
  357. package/src/substitution-levels.ts +2 -3
  358. package/src/successors.ts +267 -77
  359. package/src/symmetry.ts +31 -8
  360. package/src/tableau.ts +27 -24
  361. package/src/tlc/fingerprint.ts +183 -61
  362. package/src/tlc/jar-data.ts +113 -6
  363. package/src/tlc/messages.ts +122 -37
  364. package/src/tlc/order.ts +33 -38
  365. package/src/tlc/random.ts +16 -16
  366. package/src/tlc/replay.ts +563 -211
  367. package/src/tlc/summary.ts +2 -4
  368. package/src/tlc/tlc-operators.ts +81 -36
  369. package/src/tlc/tlcext-operators.ts +138 -117
  370. package/src/tlc/trace-spec.ts +273 -0
  371. package/src/tlc/value-stream.ts +143 -0
  372. package/src/tlc/version.ts +2 -4
  373. package/src/transfer.ts +22 -25
  374. package/src/typescript/actions.ts +481 -0
  375. package/src/typescript/collections.ts +600 -0
  376. package/src/typescript/compile.ts +65 -0
  377. package/src/typescript/context.ts +94 -0
  378. package/src/typescript/emit.ts +121 -0
  379. package/src/typescript/expressions.ts +496 -0
  380. package/src/typescript/formula.ts +152 -0
  381. package/src/typescript/functions.ts +284 -0
  382. package/src/typescript/model.ts +163 -0
  383. package/src/typescript/names.ts +114 -0
  384. package/src/typescript/program.ts +48 -0
  385. package/src/typescript/properties.ts +139 -0
  386. package/src/typescript/scope.ts +112 -0
  387. package/src/typescript/steps.ts +165 -0
  388. package/src/typescript/types.ts +171 -0
  389. package/src/values.ts +826 -276
  390. package/src/worker.ts +7 -8
@@ -1,5 +1,3 @@
1
- // Proves a module's obligations with tla-ts's own backends, in tlapm's order, or with tlapm.
2
-
3
1
  import { TlaProverError, TlaUnsupportedError } from "../errors";
4
2
  import { getChildren, mapHyp, type Expr, type Hyp, type Sequent } from "../obligations/expression";
5
3
  import { getObligations, type PrintedObligation } from "../obligations";
@@ -65,7 +63,6 @@ export interface ProveOptions {
65
63
  workers?: number;
66
64
  }
67
65
 
68
- // What one method concluded about an obligation, as tlapm's toolbox messages report it.
69
66
  export interface ProofAttempt {
70
67
  method: Method;
71
68
  isProved: boolean;
@@ -80,21 +77,16 @@ interface ProofReport {
80
77
  attempts: ProofAttempt[];
81
78
  }
82
79
 
83
- // Why a method left an obligation unproved: a prover decided so, or tla-ts couldn't try it.
84
80
  interface MethodFailure {
85
81
  reason: string;
86
82
  isDecided: boolean;
87
83
  }
88
84
 
89
- // The SMT encoder numbers the CASE errors it standardizes across the run, so an obligation it
90
- // encodes one in waits for every earlier obligation and starts from the count they leave.
91
85
  interface ObligationTask {
92
86
  done: Promise<void>;
93
87
  session: { initial: number; current: EncodingSession } | undefined;
94
88
  }
95
89
 
96
- // What tlapm keeps across one run's obligations. An obligation waits for the last earlier one with
97
- // its fingerprint, so obligations prove concurrently as they would in turn.
98
90
  interface ProveRun {
99
91
  tasks: ObligationTask[];
100
92
  results: Map<string, Map<string, ProofAttempt>>;
@@ -104,15 +96,10 @@ interface ProveRun {
104
96
  decide: DecidePool["decide"];
105
97
  }
106
98
 
107
- // The text Prep.ship sends a backend after Prep.normalize_expand. It throws a TlaUnsupportedError
108
- // for what tla-ts can't encode.
109
99
  type Encoder = (id: number, sequent: Sequent, method: Method, session: EncodingSession) => string;
110
100
 
111
- // Action.process_obligation, the frontend for every backend but LS4, Isabelle included, then
112
- // Prep.flatten.
113
101
  const shipFirstOrder = (sequent: Sequent) => flatten(processObligation(sequent));
114
102
 
115
- // Prep.gen_smt_solve writes the resource budget before the encoding.
116
103
  const encodeSmtProblem: Encoder = (_id, sequent, method, session) =>
117
104
  (method.rlimit === undefined ? "" : `(set-option :rlimit ${method.rlimit})\n`) +
118
105
  encodeSmt(shipFirstOrder(sequent), session);
@@ -121,15 +108,11 @@ const ENCODERS: Record<string, Encoder> = {
121
108
  smt: encodeSmtProblem,
122
109
  z3: encodeSmtProblem,
123
110
  zenon: (id, sequent) => encodeZenon(id, shipFirstOrder(sequent)),
124
- // tlapm names the theory after its temporary file, and tla-ts after the obligation.
125
111
  isabelle: (id, sequent, method) =>
126
112
  encodeIsabelle(id, shipFirstOrder(sequent), method.tactic ?? "auto"),
127
- // Pltl.process_obligation is LS4's frontend.
128
113
  ls4: (_id, sequent) => encodePtl(sequent),
129
114
  };
130
115
 
131
- // The frontends and Prep.flatten add no CASE without OTHER, so the SMT encoder standardizes one
132
- // only in an obligation that has one after Prep.normalize_expand.
133
116
  const hasIncompleteCase = (expression: Expr): boolean =>
134
117
  (expression.kind === "Case" && expression.other === undefined) ||
135
118
  getChildren(expression).some(hasIncompleteCase);
@@ -168,8 +151,6 @@ const getUnprovedReport = (
168
151
  attempts: ProofAttempt[] = [],
169
152
  ): ProofReport => ({ obligation: { ...getObligationBase(obligation), status, reason }, attempts });
170
153
 
171
- // A failed obligation as tlapm prints it: Prep.normalize_expand for a new failure, and
172
- // Toolbox.normalize, which keeps pragmas, for a reused one.
173
154
  export const formatNormalized = (obligation: PrintedObligation, isReused: boolean) =>
174
155
  `${formatObligation(
175
156
  isReused
@@ -177,7 +158,6 @@ export const formatNormalized = (obligation: PrintedObligation, isReused: boolea
177
158
  : normalizeExpand(obligation),
178
159
  )}\n`;
179
160
 
180
- // The theory of the proofs Isabelle found. tlapm also writes Zenon's proofs there.
181
161
  export const encodeProofTheory = (
182
162
  name: string,
183
163
  reports: ProofReport[],
@@ -199,7 +179,6 @@ export const encodeProofTheory = (
199
179
  ),
200
180
  );
201
181
 
202
- // The text one backend receives for an obligation, for comparing with tlapm's.
203
182
  export const encodeForBackend = (
204
183
  obligation: PrintedObligation,
205
184
  prover: string,
@@ -215,8 +194,6 @@ export const encodeForBackend = (
215
194
  return encode(obligation.id, normalizeExpand(obligation, methods), method, session);
216
195
  };
217
196
 
218
- // The SMT encoder's session for an obligation, from the count of CASE errors every earlier
219
- // obligation leaves.
220
197
  const getSession = async (run: ProveRun, index: number) => {
221
198
  const task = run.tasks[index];
222
199
  if (task.session) return task.session.current;
@@ -232,10 +209,6 @@ const getSession = async (run: ProveRun, index: number) => {
232
209
  return task.session.current;
233
210
  };
234
211
 
235
- // Prep.ship: the provers the step cites, or tlapm's default ones when it cites none, each tried in
236
- // turn until one proves the obligation. Prep.already_processed reuses what a prover concluded for
237
- // an earlier obligation with the same fingerprint: a proof, or a failure within at least as much
238
- // time. Unless the first prover's proof is reused, a trivial obligation needs no prover.
239
212
  const proveWithBackends = async (
240
213
  obligation: PrintedObligation,
241
214
  index: number,
@@ -255,13 +228,11 @@ const proveWithBackends = async (
255
228
  obligation: { ...getObligationBase(obligation), status: "proved", prover },
256
229
  attempts,
257
230
  });
258
- // Prep.already_processed, which forgets the fingerprint's results on each call under --nofp.
259
231
  const getPrior = (method: Method) => {
260
232
  if (!run.isFingerprinted(obligation)) run.results.delete(fingerprint);
261
233
  const prior = run.results.get(fingerprint)?.get(method.prover);
262
234
  return prior?.method.tactic === method.tactic ? prior : undefined;
263
235
  };
264
- // Fpfile.get_timeout.
265
236
  const getBudget = (method: Method) => method.rlimit ?? method.timeLimitMs / 1000;
266
237
  const reuse = (prior: ProofAttempt) =>
267
238
  attempts.push({ ...prior, isReused: true, timeUsedMs: undefined });
@@ -282,7 +253,6 @@ const proveWithBackends = async (
282
253
  return getProvedReport(firstPrior.method.prover);
283
254
  }
284
255
  const sequent = normalizeExpand(obligation, methods);
285
- // Fpfile.fp_writes keeps no trivial result, but adds the fingerprint.
286
256
  if (obligation.kind.kind === "Support" && isTrivial(sequent)) {
287
257
  run.results.set(fingerprint, run.results.get(fingerprint) ?? new Map());
288
258
  return { obligation: { ...getObligationBase(obligation), status: "trivial" }, attempts };
@@ -302,7 +272,6 @@ const proveWithBackends = async (
302
272
  continue;
303
273
  }
304
274
  if (!run.isProving) continue;
305
- // Prep.prove_with: the Trivial method proves anything.
306
275
  if (method.prover === "trivial") return getProvedReport(method.prover);
307
276
  const encode = ENCODERS[method.prover];
308
277
  if (!encode) {
@@ -352,8 +321,6 @@ const proveWithBackends = async (
352
321
  );
353
322
  };
354
323
 
355
- // An error that escapes proveWithBackends: what tla-ts can't handle is unsupported, and what tlapm
356
- // refuses, as a frontend's soundness check, fails.
357
324
  const getErrorReport = (obligation: PrintedObligation, error: unknown) => {
358
325
  if (error instanceof TlaUnsupportedError)
359
326
  return getUnprovedReport(obligation, "unsupported", error.message);
@@ -367,9 +334,7 @@ interface ObligationsOptions {
367
334
  signal?: AbortSignal;
368
335
  onReport?: (report: ProofReport, obligation: PrintedObligation) => void;
369
336
  results?: Map<string, Map<string, ProofAttempt>>;
370
- // --nofp and --nofpl.
371
337
  isFingerprinted?: (obligation: PrintedObligation) => boolean;
372
- // --noproving.
373
338
  isProving?: boolean;
374
339
  }
375
340
 
@@ -391,7 +356,6 @@ export const proveObligations = async (
391
356
  decide:
392
357
  pool?.decide ?? (async (prover, text, decideOptions) => decide(prover, text, decideOptions)),
393
358
  };
394
- // A few obligations per worker prove at once, and each reports once every earlier one has.
395
359
  const limit = pool ? workerCount * 4 : 1;
396
360
  const pending: Promise<ProofReport>[] = [];
397
361
  const isSettled: boolean[] = [];
@@ -1,17 +1,12 @@
1
- // Decides the text tlapm sends LS4, as LS4 does: unsat when the negated obligation has no model,
2
- // which proves the obligation.
3
-
4
1
  import { TlaSyntaxError } from "../../errors";
5
2
  import type { DecideOptions, Verdict } from "../verdict";
6
3
  import { getSatisfiability, type PtlFormula } from "./tableau";
7
4
 
8
- // LS4's input syntax, as tlapm writes it: every operator is parenthesized except the facts of a
9
- // sequent, which are joined by & before ->.
10
5
  const parseLs4 = (text: string): PtlFormula => {
11
6
  const tokens = text.match(/<->|->|[()~&|]|[\w']+|\S/g) ?? [];
12
- const state = { position: 0 };
7
+ let position = 0;
13
8
  const take = (expected?: string) => {
14
- const token = tokens[state.position++];
9
+ const token = tokens[position++];
15
10
  if (token === undefined || (expected !== undefined && token !== expected))
16
11
  throw new TlaSyntaxError(
17
12
  `Expected ${expected ?? "a formula"} in LS4 input, found ${token ?? "the end"}`,
@@ -35,7 +30,7 @@ const parseLs4 = (text: string): PtlFormula => {
35
30
  };
36
31
  const parseJunction = (operator: string, kind: "And" | "Or", parseOperand: () => PtlFormula) => {
37
32
  const operands = [parseOperand()];
38
- while (tokens[state.position] === operator) {
33
+ while (tokens[position] === operator) {
39
34
  take();
40
35
  operands.push(parseOperand());
41
36
  }
@@ -43,19 +38,19 @@ const parseLs4 = (text: string): PtlFormula => {
43
38
  };
44
39
  const parseImplies = (): PtlFormula => {
45
40
  const left = parseJunction("|", "Or", () => parseJunction("&", "And", parseUnary));
46
- if (tokens[state.position] !== "->") return left;
41
+ if (tokens[position] !== "->") return left;
47
42
  take();
48
43
  return { kind: "Implies", left, right: parseImplies() };
49
44
  };
50
45
  const parseEquiv = (): PtlFormula => {
51
46
  const left = parseImplies();
52
- if (tokens[state.position] !== "<->") return left;
47
+ if (tokens[position] !== "<->") return left;
53
48
  take();
54
49
  return { kind: "Equiv", left, right: parseEquiv() };
55
50
  };
56
51
  const formula = parseEquiv();
57
- if (state.position < tokens.length)
58
- throw new TlaSyntaxError(`Expected the end of LS4 input, found ${tokens[state.position]}`);
52
+ if (position < tokens.length)
53
+ throw new TlaSyntaxError(`Expected the end of LS4 input, found ${tokens[position]}`);
59
54
  return formula;
60
55
  };
61
56
 
@@ -1,8 +1,3 @@
1
- // tlapm's PTL backend up to the text it sends LS4 (Pltl.process_obligation, Prep.flatten, and
2
- // Ls4's printer): temporal operators reduce to [], <> and prime, assumptions that hold
3
- // always get a [], and every other subformula becomes an atom named by a hash of its printed form.
4
- // The text is the negated obligation.
5
-
6
1
  import {
7
2
  bumpBy,
8
3
  shift,
@@ -27,9 +22,6 @@ import { getLevelInfo } from "../../obligations/levels";
27
22
  import { expandAction, expandFairness, expandLeadsto, getTime } from "../../obligations/temporal";
28
23
  import { getHashName, LEVEL_NUMBER_PREFIXES, LEVEL_PREFIXES } from "../prep/action";
29
24
 
30
- // Coalesce.rename_with_loc: each declared name gets its kind in front, or its level for a definition,
31
- // as in VARIABLE_x_ and CONSTANT_i_, so atoms print with the names tlapm hashes. A variable a
32
- // temporal quantifier binds keeps its name.
33
25
  const renameSequent = (scope: Scope | undefined, sequent: Sequent): Sequent => {
34
26
  const [inner, context] = mapAccumulate(
35
27
  scope,
@@ -93,38 +85,30 @@ const renameDeclarations = (scope: Scope | undefined, expression: Expr): Expr =>
93
85
  }
94
86
  };
95
87
 
96
- interface PreparedHyps {
97
- scope: Scope | undefined;
98
- substitution: Substitution;
99
- context: Hyp[];
100
- }
101
-
102
- // Pltl.expand_domains and Pltl.box_assumptions: NEW x \in S becomes NEW x and the fact x \in S, and
103
- // each visible fact that holds always gets a [].
104
88
  const prepareHyps = (scope: Scope | undefined, expression: Expr): Expr => {
105
89
  if (expression.kind !== "Sequent")
106
90
  return mapScoped(scope, expression, prepareHyps, adjoin, "all");
107
- const state: PreparedHyps = { scope, substitution: shift(0), context: [] };
91
+ let innerScope = scope;
92
+ let substitution: Substitution = shift(0);
93
+ const context: Hyp[] = [];
108
94
  const push = (hyp: Hyp) => {
109
95
  const prepared =
110
96
  hyp.kind === "Fact" && hyp.visibility === "Visible" && hyp.time === "Always"
111
97
  ? { ...hyp, expression: applyBuiltin("BoxTrue", [hyp.expression], hyp.expression) }
112
98
  : hyp;
113
- state.context.push(prepared);
114
- state.scope = adjoin(state.scope, prepared);
99
+ context.push(prepared);
100
+ innerScope = adjoin(innerScope, prepared);
115
101
  };
116
102
  for (const original of expression.sequent.context) {
117
- const hyp = substituteHyp(state.substitution, original);
103
+ const hyp = substituteHyp(substitution, original);
118
104
  if (hyp.kind !== "Fresh" || !hyp.domain || original.kind !== "Fresh" || !original.domain) {
119
105
  push(
120
- hyp.kind === "Fact"
121
- ? { ...hyp, expression: prepareHyps(state.scope, hyp.expression) }
122
- : hyp,
106
+ hyp.kind === "Fact" ? { ...hyp, expression: prepareHyps(innerScope, hyp.expression) } : hyp,
123
107
  );
124
- state.substitution = bumpBy(1, state.substitution);
108
+ substitution = bumpBy(1, substitution);
125
109
  continue;
126
110
  }
127
- const domain = prepareHyps(state.scope, hyp.domain);
111
+ const domain = prepareHyps(innerScope, hyp.domain);
128
112
  push({ ...hyp, domain: undefined });
129
113
  // tlapm judges the time of the domain as written, one hypothesis too deep.
130
114
  push({
@@ -135,19 +119,19 @@ const prepareHyps = (scope: Scope | undefined, expression: Expr): Expr => {
135
119
  domain,
136
120
  ),
137
121
  visibility: hyp.domainVisibility,
138
- time: hyp.level === "Constant" ? getTime(state.scope, original.domain) : "Now",
122
+ time: hyp.level === "Constant" ? getTime(innerScope, original.domain) : "Now",
139
123
  location: hyp.location,
140
124
  });
141
- state.substitution = {
125
+ substitution = {
142
126
  kind: "Compose",
143
127
  outer: shift(1),
144
- inner: bumpBy(1, state.substitution),
128
+ inner: bumpBy(1, substitution),
145
129
  };
146
130
  }
147
- const active = substituteExpr(state.substitution, expression.sequent.active);
131
+ const active = substituteExpr(substitution, expression.sequent.active);
148
132
  return {
149
133
  ...expression,
150
- sequent: { context: state.context, active: prepareHyps(state.scope, active) },
134
+ sequent: { context, active: prepareHyps(innerScope, active) },
151
135
  };
152
136
  };
153
137
 
@@ -166,8 +150,6 @@ const UNARY: Partial<Record<Builtin, string>> = {
166
150
  Prime: "next",
167
151
  };
168
152
 
169
- // Prep.flatten, which tlapm applies after Pltl.process_obligation has made every equality an atom:
170
- // TRUE drops out of the conjunctions of each visible fact, and a fact left with nothing disappears.
171
153
  const removeTrue = (expression: Expr): Expr | undefined => {
172
154
  if (expression.kind === "Internal" && expression.builtin === "TRUE") return undefined;
173
155
  if (expression.kind === "List" && expression.bullet !== "Or") {
@@ -189,10 +171,7 @@ const removeTrue = (expression: Expr): Expr | undefined => {
189
171
 
190
172
  const TRUE_TEXT = "(cc | ~ cc)";
191
173
 
192
- // The text tlapm sends LS4 for an obligation after Prep.normalize_expand.
193
174
  export const encodePtl = (sequent: Sequent): string => {
194
- // Ls4's printer. A sequent becomes an implication from its visible facts, joined by &, and
195
- // Prep.flatten applies to the facts of the outermost one.
196
175
  const print = (hyps: Hyp[], expression: Expr, isOutermost = false): string => {
197
176
  const recurse = (inner: Expr) => print(hyps, inner);
198
177
  switch (expression.kind) {
@@ -235,7 +214,6 @@ export const encodePtl = (sequent: Sequent): string => {
235
214
  return facts.length === 0 ? goal : `(${facts.join(" & ")} -> ${goal})`;
236
215
  }
237
216
  }
238
- // Pltl.coalesce_fol names an atom as Coalesce does.
239
217
  return getHashName(hyps, expression);
240
218
  };
241
219
  const renamed = renameDeclarations(undefined, { kind: "Sequent", sequent });
@@ -1,9 +1,3 @@
1
- // A conflict-driven clause learning SAT solver for the clauses of one tableau node. A literal is a
2
- // variable number, negated when below zero. The solver keeps what it learns across calls, which add
3
- // clauses or assume literals. It decides each open variable false first, so a model sets few
4
- // variables, and a model holds 1 for each true variable and -1 for each false one. It gives up at
5
- // the first conflict after isExpired turns true.
6
-
7
1
  const getIndex = (literal: number) => (literal > 0 ? 2 * literal : -2 * literal + 1);
8
2
 
9
3
  export const createSolver = (variableCount: number, isExpired: () => boolean) => {
@@ -15,7 +9,9 @@ export const createSolver = (variableCount: number, isExpired: () => boolean) =>
15
9
  const watches: number[][][] = Array.from({ length: 2 * variableCount + 2 }, () => []);
16
10
  const trail: number[] = [];
17
11
  const levelStarts: number[] = [];
18
- const state = { head: 0, bump: 1, isUnsatisfiable: false };
12
+ let head = 0;
13
+ let bump = 1;
14
+ let isUnsatisfiable = false;
19
15
  const getValue = (literal: number) => (literal > 0 ? values[literal] : -values[-literal]);
20
16
  const assign = (literal: number, reason: number[] | undefined) => {
21
17
  const variable = Math.abs(literal);
@@ -28,11 +24,9 @@ export const createSolver = (variableCount: number, isExpired: () => boolean) =>
28
24
  watches[getIndex(clause[0])].push(clause);
29
25
  watches[getIndex(clause[1])].push(clause);
30
26
  };
31
- // Moves each watch off a literal that turned false, and returns the clause of a conflict. The
32
- // literal a clause implies sits first in it.
33
27
  const propagate = () => {
34
- for (; state.head < trail.length; state.head++) {
35
- const falsified = -trail[state.head];
28
+ for (; head < trail.length; head++) {
29
+ const falsified = -trail[head];
36
30
  const watching = watches[getIndex(falsified)];
37
31
  for (let position = 0; position < watching.length; position++) {
38
32
  const clause = watching[position];
@@ -59,39 +53,38 @@ export const createSolver = (variableCount: number, isExpired: () => boolean) =>
59
53
  const size = levelStarts[level];
60
54
  while (trail.length > size) values[Math.abs(trail.pop() ?? 0)] = 0;
61
55
  levelStarts.length = level;
62
- state.head = trail.length;
56
+ head = trail.length;
63
57
  };
64
- // Resolves the conflict back to the first literal of the current level that all its paths pass
65
- // through, and returns the learned clause with that literal first.
66
58
  const analyze = (conflict: number[]) => {
67
59
  const learned = [0];
68
60
  const current = levelStarts.length;
69
- const walk = { pending: 0, literal: 0, index: trail.length - 1 };
61
+ let pendingCount = 0;
62
+ let resolved = 0;
63
+ let trailIndex = trail.length - 1;
70
64
  for (let clause: number[] | undefined = conflict; ;) {
71
- for (const literal of clause?.slice(walk.literal === 0 ? 0 : 1) ?? []) {
65
+ for (const literal of clause?.slice(resolved === 0 ? 0 : 1) ?? []) {
72
66
  const variable = Math.abs(literal);
73
67
  if (seen[variable] || levels[variable] === 0) continue;
74
68
  seen[variable] = 1;
75
- activities[variable] += state.bump;
76
- if (levels[variable] === current) walk.pending++;
69
+ activities[variable] += bump;
70
+ if (levels[variable] === current) pendingCount++;
77
71
  else learned.push(literal);
78
72
  }
79
- while (!seen[Math.abs(trail[walk.index])]) walk.index--;
80
- walk.literal = trail[walk.index--];
81
- seen[Math.abs(walk.literal)] = 0;
82
- clause = reasons[Math.abs(walk.literal)];
83
- if (--walk.pending === 0) break;
73
+ while (!seen[Math.abs(trail[trailIndex])]) trailIndex--;
74
+ resolved = trail[trailIndex--];
75
+ seen[Math.abs(resolved)] = 0;
76
+ clause = reasons[Math.abs(resolved)];
77
+ if (--pendingCount === 0) break;
84
78
  }
85
- learned[0] = -walk.literal;
79
+ learned[0] = -resolved;
86
80
  learned.forEach((literal) => (seen[Math.abs(literal)] = 0));
87
- state.bump *= 1.05;
81
+ bump *= 1.05;
88
82
  return learned;
89
83
  };
90
- // Literals false for good are dropped, since the solver adds clauses only at level 0.
91
84
  const addClause = (clause: number[]) => {
92
85
  backtrack(0);
93
86
  const literals = [...new Set(clause)];
94
- if (state.isUnsatisfiable || literals.some((literal) => getValue(literal) > 0)) return;
87
+ if (isUnsatisfiable || literals.some((literal) => getValue(literal) > 0)) return;
95
88
  if (literals.some((literal) => literals.includes(-literal))) return;
96
89
  const open = literals.filter((literal) => getValue(literal) === 0);
97
90
  if (open.length > 1) {
@@ -99,21 +92,20 @@ export const createSolver = (variableCount: number, isExpired: () => boolean) =>
99
92
  return;
100
93
  }
101
94
  if (open.length === 0) {
102
- state.isUnsatisfiable = true;
95
+ isUnsatisfiable = true;
103
96
  return;
104
97
  }
105
98
  assign(open[0], undefined);
106
- if (propagate()) state.isUnsatisfiable = true;
99
+ if (propagate()) isUnsatisfiable = true;
107
100
  };
108
- // A model of the clauses in which every assumed literal holds, or unsat when there is none.
109
101
  const solve = (assumptions: number[]): Int8Array | "unsat" | "unknown" => {
110
102
  backtrack(0);
111
- if (state.isUnsatisfiable) return "unsat";
103
+ if (isUnsatisfiable) return "unsat";
112
104
  for (;;) {
113
105
  const conflict = propagate();
114
106
  if (conflict) {
115
107
  if (levelStarts.length === 0) {
116
- state.isUnsatisfiable = true;
108
+ isUnsatisfiable = true;
117
109
  return "unsat";
118
110
  }
119
111
  if (isExpired()) return "unknown";
@@ -1,8 +1,3 @@
1
- // Decides satisfiability of propositional linear temporal logic over infinite traces, the logic LS4
2
- // decides. A tableau node is the set of formulas that must hold now. A SAT call per step picks the
3
- // atoms and the formulas the next node must hold, and the formula is satisfiable when a reachable
4
- // strongly connected component can fulfill every eventuality it postpones.
5
-
6
1
  import type { Verdict } from "../verdict";
7
2
  import { createSolver } from "./sat";
8
3
 
@@ -11,7 +6,6 @@ export type PtlFormula =
11
6
  | { kind: "Not" | "Next" | "Always" | "Eventually"; body: PtlFormula }
12
7
  | { kind: "And" | "Or" | "Implies" | "Equiv"; left: PtlFormula; right: PtlFormula };
13
8
 
14
- // Formulas in negation normal form, numbered so that equal formulas share a number.
15
9
  type Normal =
16
10
  | { kind: "Constant"; value: boolean }
17
11
  | { kind: "Literal"; atom: string; isPositive: boolean }
@@ -40,19 +34,19 @@ const createTable = () => {
40
34
  };
41
35
  const getConstant = (value: boolean) => intern(String(value), { kind: "Constant", value });
42
36
  const getJunction = (kind: "And" | "Or", operands: number[]): number => {
43
- const absorbing = kind === "Or";
37
+ const isAbsorbing = kind === "Or";
44
38
  const children = new Set<number>();
45
39
  for (const operand of operands) {
46
40
  const normal = normals[operand];
47
41
  if (normal.kind === "Constant") {
48
- if (normal.value === absorbing) return operand;
42
+ if (normal.value === isAbsorbing) return operand;
49
43
  continue;
50
44
  }
51
45
  if (normal.kind === kind) normal.children.forEach((child) => children.add(child));
52
46
  else children.add(operand);
53
47
  }
54
48
  const sorted = [...children].sort((left, right) => left - right);
55
- if (sorted.length === 0) return getConstant(!absorbing);
49
+ if (sorted.length === 0) return getConstant(!isAbsorbing);
56
50
  if (sorted.length === 1) return sorted[0];
57
51
  return intern(`${kind}(${sorted.join(",")})`, { kind, children: sorted });
58
52
  };
@@ -114,10 +108,6 @@ const createTable = () => {
114
108
  return { normals, normalize };
115
109
  };
116
110
 
117
- // Every way to satisfy the formulas now, keeping only the steps that require the fewest next
118
- // formulas and leave the fewest eventualities pending. A step that requires more of both can only
119
- // do what a smaller one can, so dropping it keeps the decision complete. Undefined once isExpired
120
- // turns true.
121
111
  const getSteps = (
122
112
  normals: Normal[],
123
113
  formulas: number[],
@@ -128,8 +118,8 @@ const getSteps = (
128
118
  const nexts = new Map<number, number>();
129
119
  const pendings = new Map<number, number>();
130
120
  const literals = new Map<number, number>();
131
- const counter = { value: 0 };
132
- const createVariable = () => ++counter.value;
121
+ let variableCount = 0;
122
+ const createVariable = () => ++variableCount;
133
123
  const getVariable = <Key>(variables: Map<Key, number>, key: Key) => {
134
124
  const existing = variables.get(key);
135
125
  if (existing !== undefined) return existing;
@@ -137,7 +127,6 @@ const getSteps = (
137
127
  variables.set(key, variable);
138
128
  return variable;
139
129
  };
140
- // Plaisted-Greenbaum: a formula's literal implies the formula, which suffices in normal form.
141
130
  const encode = (formula: number): number => {
142
131
  const cached = literals.get(formula);
143
132
  if (cached !== undefined) return cached;
@@ -184,14 +173,12 @@ const getSteps = (
184
173
  };
185
174
  formulas.forEach((formula) => clauses.push([encode(formula)]));
186
175
  const choices = [...nexts.values(), ...pendings.values()];
187
- const solver = createSolver(counter.value, isExpired);
176
+ const solver = createSolver(variableCount, isExpired);
188
177
  clauses.forEach(solver.addClause);
189
178
  const steps: Step[] = [];
190
179
  for (;;) {
191
180
  const model = solver.solve([]);
192
181
  if (typeof model === "string") return model === "unsat" ? steps : undefined;
193
- // Drops each chosen variable that a model with no other choice can do without. A variable one
194
- // pass keeps stays needed as the set shrinks, so the set that remains is minimal.
195
182
  const minimal = choices.reduce<Int8Array | undefined>((current, choice) => {
196
183
  if (current?.[choice] !== 1) return current;
197
184
  const unchosen = choices.filter((other) => current[other] !== 1);
@@ -209,7 +196,6 @@ const getSteps = (
209
196
  }
210
197
  };
211
198
 
212
- // Whether the formula is satisfiable, or unknown once isExpired turns true.
213
199
  export const getSatisfiability = (formula: PtlFormula, isExpired: () => boolean): Verdict => {
214
200
  const table = createTable();
215
201
  const nodes: number[][] = [];
@@ -230,12 +216,12 @@ export const getSatisfiability = (formula: PtlFormula, isExpired: () => boolean)
230
216
  if (!steps) return "unknown";
231
217
  edges.push(steps.map((step) => ({ target: getNode(step.next), pending: step.pending })));
232
218
  }
233
- // Tarjan's algorithm, checking each component as it closes.
234
219
  const indices = new Int32Array(nodes.length).fill(-1);
235
220
  const lowlinks = new Int32Array(nodes.length);
236
221
  const components = new Int32Array(nodes.length).fill(-1);
237
222
  const stack: number[] = [];
238
- const counter = { index: 0, component: 0 };
223
+ let nextIndex = 0;
224
+ let componentCount = 0;
239
225
  const isFair = (component: number) => {
240
226
  const inner = edges.flatMap((outgoing, source) =>
241
227
  components[source] === component
@@ -252,9 +238,9 @@ export const getSatisfiability = (formula: PtlFormula, isExpired: () => boolean)
252
238
  return unfulfilled.length === 0;
253
239
  };
254
240
  const visit = (node: number): boolean => {
255
- indices[node] = counter.index;
256
- lowlinks[node] = counter.index;
257
- counter.index++;
241
+ indices[node] = nextIndex;
242
+ lowlinks[node] = nextIndex;
243
+ nextIndex++;
258
244
  stack.push(node);
259
245
  for (const edge of edges[node]) {
260
246
  if (indices[edge.target] === -1) {
@@ -265,7 +251,7 @@ export const getSatisfiability = (formula: PtlFormula, isExpired: () => boolean)
265
251
  }
266
252
  }
267
253
  if (lowlinks[node] !== indices[node]) return false;
268
- const component = counter.component++;
254
+ const component = componentCount++;
269
255
  for (let member = stack.pop(); member !== undefined; member = stack.pop()) {
270
256
  components[member] = component;
271
257
  if (member === node) break;
@@ -1,5 +1,3 @@
1
- // encode/n_axioms.ml: the formulas of the axioms that depend on a count or on fields.
2
-
3
1
  import {
4
2
  call,
5
3
  CAST_INT,
@@ -18,7 +16,6 @@ import {
18
16
  } from "./format";
19
17
  import { axiom, TYPED_SYMBOLS, type AxiomArgument } from "./table";
20
18
 
21
- // The arithmetic symbols with a Typing axiom: each one's SMT-LIB operator and arity.
22
19
  export const TYPED_OPERATORS: Record<string, [string, number]> = {
23
20
  IntPlus: ["+", 2],
24
21
  IntMinus: ["-", 2],
@@ -79,7 +76,6 @@ export const getIntegers = (count: number) =>
79
76
 
80
77
  export const getFieldKeys = (fields: string[]) => fields.map((field) => tla(`StrLit_${field}`));
81
78
 
82
- // TupExcept and RecExcept: updating one component of a tuple or record.
83
79
  const getComponentExcepts = (
84
80
  prefix: string,
85
81
  args: AxiomArgument[],
@@ -104,8 +100,6 @@ export const getTupleExcepts = (count: number) =>
104
100
  export const getRecordExcepts = (fields: string[]) =>
105
101
  getComponentExcepts("Rec", [fields], tla(`Record_${fields.join("_")}`), getFieldKeys(fields));
106
102
 
107
- // TupIsafcn, TupDomDef and TupAppDef, or their Rec counterparts: a tuple or record is the
108
- // function from its keys to its components. The empty tuple has no domain or components to define.
109
103
  const getComponentFunction = (
110
104
  prefix: string,
111
105
  args: AxiomArgument[],
@@ -172,7 +166,6 @@ export const getRecordAxioms = (fields: string[], isExcept: boolean) => [
172
166
  ...(isExcept ? getRecordExcepts(fields) : []),
173
167
  ];
174
168
 
175
- // The set of tuples or records whose components are in the given sets.
176
169
  export const getComponentSet = (
177
170
  name: string,
178
171
  args: AxiomArgument[],