tla-ts 0.0.4-dev.fa107ef → 0.0.5-dev.552d313

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 (378) hide show
  1. package/README.md +38 -127
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +44 -12
  8. package/dist/index.d.ts +44 -12
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +76 -92
  23. package/dist/transfer.js +76 -92
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +21 -12
  27. package/src/ast.ts +2 -2
  28. package/src/bags.ts +22 -23
  29. package/src/builtins.ts +16 -8
  30. package/src/check.ts +131 -1153
  31. package/src/{cli-options.ts → cli/options.ts} +54 -9
  32. package/src/cli/run.ts +63 -0
  33. package/src/cli/shared.ts +106 -0
  34. package/src/cli/tlapm.ts +374 -0
  35. package/src/{run-cli.ts → cli/tlc.ts} +115 -721
  36. package/src/cli/xml-exporter.ts +221 -0
  37. package/src/cli.ts +1 -1
  38. package/src/codegen.ts +43 -22
  39. package/src/config.ts +5 -5
  40. package/src/dependencies.ts +4 -6
  41. package/src/environment.ts +55 -60
  42. package/src/errors.ts +97 -35
  43. package/src/evaluate.ts +135 -120
  44. package/src/exit-codes.ts +1 -1
  45. package/src/fingerprints.ts +3 -3
  46. package/src/index.ts +10 -0
  47. package/src/instances.ts +56 -46
  48. package/src/java-overrides.ts +79 -41
  49. package/src/json.ts +31 -36
  50. package/src/levels.ts +10 -13
  51. package/src/{live-check.ts → liveness-checker.ts} +169 -142
  52. package/src/liveness.ts +38 -34
  53. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  54. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  55. package/src/obligations/equality.ts +260 -0
  56. package/src/obligations/expression.ts +618 -0
  57. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  58. package/src/obligations/generate.ts +457 -0
  59. package/src/{obligations.ts → obligations/index.ts} +46 -32
  60. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  61. package/src/obligations/module.ts +445 -0
  62. package/src/obligations/normalize.ts +554 -0
  63. package/src/obligations/operators.ts +176 -0
  64. package/src/obligations/pragma.ts +195 -0
  65. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  66. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  67. package/src/obligations/regroup.ts +100 -0
  68. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  69. package/src/{obligation-source.ts → obligations/source.ts} +172 -216
  70. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  71. package/src/obligations/substitution.ts +261 -0
  72. package/src/obligations/temporal.ts +321 -0
  73. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  74. package/src/parallel-worker.ts +39 -51
  75. package/src/parallel.ts +39 -66
  76. package/src/parser.ts +67 -74
  77. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  78. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  79. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  80. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  81. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  82. package/src/prover/decide-pool.ts +95 -0
  83. package/src/prover/deciders.ts +33 -0
  84. package/src/prover/first-order.ts +175 -0
  85. package/src/prover/isabelle/LICENSE +36 -0
  86. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  87. package/src/prover/isabelle/decide.ts +44 -0
  88. package/src/prover/isabelle/encode.ts +445 -0
  89. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  90. package/src/prover/isabelle/isar/method.ts +367 -0
  91. package/src/prover/isabelle/isar/proof.ts +28 -0
  92. package/src/prover/isabelle/isar/statement.ts +57 -0
  93. package/src/prover/isabelle/isar/theory.ts +192 -0
  94. package/src/prover/isabelle/isar/type-check.ts +278 -0
  95. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  96. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  97. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  98. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  99. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  100. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  101. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  102. package/src/prover/isabelle/provers/classical.ts +389 -0
  103. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  104. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  105. package/src/prover/isabelle/pure/consts.ts +32 -0
  106. package/src/prover/isabelle/pure/conv.ts +79 -0
  107. package/src/prover/isabelle/pure/drule.ts +264 -0
  108. package/src/prover/isabelle/pure/envir.ts +331 -0
  109. package/src/prover/isabelle/pure/goal.ts +53 -0
  110. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  111. package/src/prover/isabelle/pure/list.ts +12 -0
  112. package/src/prover/isabelle/pure/logic.ts +330 -0
  113. package/src/prover/isabelle/pure/name.ts +98 -0
  114. package/src/prover/isabelle/pure/net.ts +215 -0
  115. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  116. package/src/prover/isabelle/pure/pattern.ts +631 -0
  117. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  118. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  119. package/src/prover/isabelle/pure/search.ts +68 -0
  120. package/src/prover/isabelle/pure/seq.ts +133 -0
  121. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  122. package/src/prover/isabelle/pure/table.ts +201 -0
  123. package/src/prover/isabelle/pure/tactic.ts +168 -0
  124. package/src/prover/isabelle/pure/tactical.ts +264 -0
  125. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  126. package/src/prover/isabelle/pure/term.ts +688 -0
  127. package/src/prover/isabelle/pure/thm.ts +783 -0
  128. package/src/prover/isabelle/pure/type.ts +121 -0
  129. package/src/prover/isabelle/pure/unify.ts +753 -0
  130. package/src/prover/isabelle/pure/variable.ts +25 -0
  131. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  132. package/src/prover/isabelle/tla/context.ts +74 -0
  133. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  134. package/src/prover/isabelle/tla/logic.ts +215 -0
  135. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  136. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  137. package/src/prover/ocaml.ts +22 -0
  138. package/src/prover/prep/action.ts +508 -0
  139. package/src/prover/prep/enabled-axioms.ts +189 -0
  140. package/src/prover/prep/fingerprint.ts +388 -0
  141. package/src/prover/prep/level-comparison.ts +529 -0
  142. package/src/prover/prep/md5.ts +60 -0
  143. package/src/prover/prep/methods.ts +221 -0
  144. package/src/prover/prep/normalize.ts +309 -0
  145. package/src/prover/prove-worker.ts +22 -0
  146. package/src/prover/prove.ts +492 -0
  147. package/src/prover/ptl/decide.ts +68 -0
  148. package/src/prover/ptl/encode.ts +244 -0
  149. package/src/prover/ptl/sat.ts +151 -0
  150. package/src/prover/ptl/tableau.ts +276 -0
  151. package/src/prover/smt/axioms.ts +209 -0
  152. package/src/prover/smt/context.ts +108 -0
  153. package/src/prover/smt/data.ts +636 -0
  154. package/src/prover/smt/encode.ts +275 -0
  155. package/src/prover/smt/extensionality.ts +65 -0
  156. package/src/prover/smt/flatten.ts +112 -0
  157. package/src/prover/smt/format.ts +154 -0
  158. package/src/prover/smt/instances.ts +181 -0
  159. package/src/prover/smt/rewrite.ts +766 -0
  160. package/src/prover/smt/solver/act-cache.ts +265 -0
  161. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  162. package/src/prover/smt/solver/array.ts +22 -0
  163. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  164. package/src/prover/smt/solver/ast-lt.ts +157 -0
  165. package/src/prover/smt/solver/ast-util.ts +91 -0
  166. package/src/prover/smt/solver/ast.ts +1315 -0
  167. package/src/prover/smt/solver/auf-solver.ts +572 -0
  168. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  169. package/src/prover/smt/solver/cg-table.ts +175 -0
  170. package/src/prover/smt/solver/clause.ts +276 -0
  171. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  172. package/src/prover/smt/solver/context.ts +1292 -0
  173. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  174. package/src/prover/smt/solver/der.ts +224 -0
  175. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  176. package/src/prover/smt/solver/e-matching.ts +659 -0
  177. package/src/prover/smt/solver/enode.ts +259 -0
  178. package/src/prover/smt/solver/expr-ref.ts +21 -0
  179. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  180. package/src/prover/smt/solver/fingerprints.ts +92 -0
  181. package/src/prover/smt/solver/flat-literals.ts +51 -0
  182. package/src/prover/smt/solver/goal.ts +138 -0
  183. package/src/prover/smt/solver/hash.ts +173 -0
  184. package/src/prover/smt/solver/hashtable.ts +166 -0
  185. package/src/prover/smt/solver/internalizer.ts +1381 -0
  186. package/src/prover/smt/solver/lbool.ts +5 -0
  187. package/src/prover/smt/solver/literal.ts +24 -0
  188. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  189. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  190. package/src/prover/smt/solver/lp/containers.ts +296 -0
  191. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  192. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  193. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  194. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  195. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  196. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  197. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  198. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  199. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  200. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  201. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  202. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  203. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  204. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  205. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  206. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  207. package/src/prover/smt/solver/lp/nex.ts +120 -0
  208. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  209. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  210. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  211. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  212. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  213. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  214. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  215. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  216. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  217. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  218. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  219. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  220. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  221. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  222. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  223. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  224. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  225. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  226. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  227. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  228. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  229. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  230. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  231. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  232. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  233. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  234. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  235. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  236. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  237. package/src/prover/smt/solver/model-checker.ts +347 -0
  238. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  239. package/src/prover/smt/solver/model-finder.ts +155 -0
  240. package/src/prover/smt/solver/model-generator.ts +97 -0
  241. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  242. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  243. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  244. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  245. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  246. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  247. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  248. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  249. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  250. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  251. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  252. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +645 -0
  253. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  254. package/src/prover/smt/solver/nnf.ts +469 -0
  255. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  256. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  257. package/src/prover/smt/solver/propagate-values.ts +83 -0
  258. package/src/prover/smt/solver/proto-model.ts +551 -0
  259. package/src/prover/smt/solver/pull-quant.ts +139 -0
  260. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  261. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  262. package/src/prover/smt/solver/qe-lite.ts +381 -0
  263. package/src/prover/smt/solver/qi-queue.ts +362 -0
  264. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  265. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  266. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  267. package/src/prover/smt/solver/random-gen.ts +10 -0
  268. package/src/prover/smt/solver/rational.ts +165 -0
  269. package/src/prover/smt/solver/ref-vector.ts +62 -0
  270. package/src/prover/smt/solver/relevancy.ts +247 -0
  271. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  272. package/src/prover/smt/solver/rewriter.ts +843 -0
  273. package/src/prover/smt/solver/rlimit.ts +79 -0
  274. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  275. package/src/prover/smt/solver/solver.ts +71 -0
  276. package/src/prover/smt/solver/sort.ts +35 -0
  277. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  278. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  279. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  280. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  281. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  282. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  283. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  284. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  285. package/src/prover/smt/solver/theory-lra.ts +56 -0
  286. package/src/prover/smt/solver/var-subst.ts +258 -0
  287. package/src/prover/smt/solver/z3-license.txt +10 -0
  288. package/src/prover/smt/table.ts +170 -0
  289. package/src/prover/tlapm/cache.ts +236 -0
  290. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  291. package/src/prover/tlapm/tlapm.ts +96 -0
  292. package/src/prover/tlaps-module.ts +510 -0
  293. package/src/prover/verdict.ts +13 -0
  294. package/src/prover/zenon/LICENSE +32 -0
  295. package/src/prover/zenon/check/check.ts +105 -0
  296. package/src/prover/zenon/check/definitions.ts +144 -0
  297. package/src/prover/zenon/check/equality.ts +182 -0
  298. package/src/prover/zenon/check/functions.ts +62 -0
  299. package/src/prover/zenon/check/keys.ts +125 -0
  300. package/src/prover/zenon/check/propositional.ts +104 -0
  301. package/src/prover/zenon/check/records.ts +188 -0
  302. package/src/prover/zenon/check/relations.ts +121 -0
  303. package/src/prover/zenon/check/rewrites.ts +224 -0
  304. package/src/prover/zenon/check/sets.ts +302 -0
  305. package/src/prover/zenon/check/terms.ts +127 -0
  306. package/src/prover/zenon/check/tla.ts +126 -0
  307. package/src/prover/zenon/decide.ts +107 -0
  308. package/src/prover/zenon/encode.ts +378 -0
  309. package/src/prover/zenon/eqrel.ts +300 -0
  310. package/src/prover/zenon/equality-rules.ts +435 -0
  311. package/src/prover/zenon/expr.ts +551 -0
  312. package/src/prover/zenon/index-table.ts +350 -0
  313. package/src/prover/zenon/isar-case.ts +513 -0
  314. package/src/prover/zenon/isar.ts +1249 -0
  315. package/src/prover/zenon/limits.ts +15 -0
  316. package/src/prover/zenon/llproof.ts +173 -0
  317. package/src/prover/zenon/mltoll.ts +1566 -0
  318. package/src/prover/zenon/node.ts +297 -0
  319. package/src/prover/zenon/ocaml.ts +169 -0
  320. package/src/prover/zenon/parse.ts +247 -0
  321. package/src/prover/zenon/phrase.ts +191 -0
  322. package/src/prover/zenon/proof.ts +198 -0
  323. package/src/prover/zenon/propositional-rules.ts +387 -0
  324. package/src/prover/zenon/rules.ts +94 -0
  325. package/src/prover/zenon/search.ts +288 -0
  326. package/src/prover/zenon/tla/functions.ts +151 -0
  327. package/src/prover/zenon/tla/llproof.ts +480 -0
  328. package/src/prover/zenon/tla/records.ts +225 -0
  329. package/src/prover/zenon/tla/rewrites.ts +447 -0
  330. package/src/prover/zenon/tla/sets.ts +304 -0
  331. package/src/prover/zenon/tla/terms.ts +162 -0
  332. package/src/prover/zenon/tla/tla.ts +506 -0
  333. package/src/randomization.ts +19 -24
  334. package/src/resolve.ts +15 -22
  335. package/src/runtime.ts +8 -8
  336. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  337. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  338. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  339. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  340. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  341. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  342. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  343. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  344. package/src/{sany-report.ts → sany/report.ts} +16 -17
  345. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  346. package/src/{sany-source.ts → sany/source.ts} +6 -7
  347. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  348. package/src/search.ts +969 -0
  349. package/src/spec-description.ts +26 -20
  350. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  351. package/src/standard-modules.ts +21 -22
  352. package/src/state-graph.ts +9 -8
  353. package/src/substitution-levels.ts +2 -2
  354. package/src/successors.ts +38 -22
  355. package/src/symmetry.ts +1 -1
  356. package/src/tableau.ts +6 -7
  357. package/src/tlc/fingerprint.ts +214 -0
  358. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  359. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  360. package/src/{tlc-random.ts → tlc/random.ts} +3 -190
  361. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  362. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  363. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  364. package/src/{tlc-version.ts → tlc/version.ts} +8 -7
  365. package/src/transfer.ts +32 -32
  366. package/src/values.ts +154 -105
  367. package/src/worker.ts +62 -0
  368. package/dist/parallel.cjs +0 -12
  369. package/dist/parallel.js +0 -12
  370. package/dist/run-cli.cjs +0 -55
  371. package/dist/run-cli.js +0 -55
  372. package/src/canonical.ts +0 -40
  373. package/src/obligation-expression.ts +0 -1060
  374. package/src/obligation-module.ts +0 -1042
  375. package/src/standard-ranges.ts +0 -116
  376. package/src/value-sources.ts +0 -29
  377. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  378. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
@@ -0,0 +1,221 @@
1
+ // Prep.find_meth and Prep.compute_meth: the methods the pragmas an obligation cites select, each a
2
+ // prover with its time limit, or a frontend that rewrites the obligation first. A malformed method
3
+ // throws a TlaProverError, since Prep.ship catches compute_meth's failure and fails only that
4
+ // obligation.
5
+
6
+ import { TlapmBugError, TlaProverError } from "../../errors";
7
+ import type { Expr, Locus, Sequent } from "../../obligations/expression";
8
+ import type { OldMethod, PragmaSetting } from "../../obligations/pragma";
9
+
10
+ // A method, named after the Method.t constructor tlapm reports it by. A Z3 resource budget turns
11
+ // the time limit off.
12
+ export interface Method {
13
+ prover: string;
14
+ timeLimitMs: number;
15
+ rlimit?: number;
16
+ tactic?: string;
17
+ }
18
+
19
+ // The methods that rewrite an obligation in Prep.expand_enabled_cdot instead of proving it.
20
+ const FRONTENDS = new Set([
21
+ "expandenabled",
22
+ "expandcdot",
23
+ "autouse",
24
+ "lambdify",
25
+ "enabledaxioms",
26
+ "levelcomparison",
27
+ ]);
28
+
29
+ // Method.default_*_timeout, in seconds.
30
+ const SMT_SECONDS = 5;
31
+ const ZENON_SECONDS = 10;
32
+ const ISABELLE_SECONDS = 30;
33
+ const LS4_SECONDS = 10;
34
+
35
+ // Method.rlimit_base and Method.max_rlimit.
36
+ const RLIMIT_BASE = 3_000_000;
37
+ const MAX_RLIMIT = 0xffff_ffff;
38
+
39
+ // Params.default_method: what tlapm tries when a step cites no prover.
40
+ const DEFAULT_METHODS: Method[] = [
41
+ { prover: "smt", timeLimitMs: SMT_SECONDS * 1000 },
42
+ { prover: "zenon", timeLimitMs: ZENON_SECONDS * 1000 },
43
+ { prover: "isabelle", timeLimitMs: ISABELLE_SECONDS * 1000, tactic: "auto" },
44
+ ];
45
+
46
+ // compute_meth's names for each prover, and the Method.t constructor and default time each
47
+ // selects. The SMT solvers take a resource budget.
48
+ const PROVERS: Record<string, { prover: string; seconds: number; isBudgeted?: boolean }> = {
49
+ zenon: { prover: "zenon", seconds: ZENON_SECONDS },
50
+ isabelle: { prover: "isabelle", seconds: ISABELLE_SECONDS },
51
+ yices: { prover: "yices", seconds: 30 },
52
+ ls4: { prover: "ls4", seconds: LS4_SECONDS },
53
+ z3: { prover: "z3", seconds: SMT_SECONDS, isBudgeted: true },
54
+ smt: { prover: "smt", seconds: SMT_SECONDS, isBudgeted: true },
55
+ cvc3: { prover: "cvc3", seconds: SMT_SECONDS },
56
+ cooper: { prover: "cooper", seconds: 0 },
57
+ fail: { prover: "fail", seconds: 0 },
58
+ smt2lib: { prover: "smt", seconds: SMT_SECONDS, isBudgeted: true },
59
+ smt2z3: { prover: "z3", seconds: SMT_SECONDS, isBudgeted: true },
60
+ smt3: { prover: "smt", seconds: SMT_SECONDS, isBudgeted: true },
61
+ z33: { prover: "z3", seconds: SMT_SECONDS, isBudgeted: true },
62
+ cvc33: { prover: "cvc3", seconds: SMT_SECONDS },
63
+ yices3: { prover: "yices", seconds: SMT_SECONDS },
64
+ verit: { prover: "verit", seconds: SMT_SECONDS },
65
+ zipper: { prover: "zipper", seconds: 30 },
66
+ spass: { prover: "spass", seconds: SMT_SECONDS },
67
+ tptp: { prover: "tptp", seconds: SMT_SECONDS },
68
+ trivial: { prover: "trivial", seconds: 0 },
69
+ ...Object.fromEntries([...FRONTENDS].map((name) => [name, { prover: name, seconds: 0 }])),
70
+ };
71
+
72
+ const getProverMethod = (
73
+ name: string,
74
+ timeout: number | undefined,
75
+ rlimit: number | undefined,
76
+ tactic: string | undefined,
77
+ ): Method => {
78
+ const known = PROVERS[name];
79
+ if (!known) throw new TlaProverError(`Unknown prover: ${name}`);
80
+ if (rlimit !== undefined && !known.isBudgeted)
81
+ throw new TlaProverError(
82
+ 'A Z3 rlimit budget ("rN") is only supported by the SMT and Z3 backends.',
83
+ );
84
+ return {
85
+ prover: known.prover,
86
+ timeLimitMs: rlimit === undefined ? (timeout ?? known.seconds) * 1000 : Infinity,
87
+ ...(rlimit !== undefined && { rlimit }),
88
+ ...(known.prover === "isabelle" && { tactic: tactic ?? "auto" }),
89
+ };
90
+ };
91
+
92
+ // parse_rlimit: "rN" is N times the base resource count, at least 1.
93
+ const getRlimit = (budget: string) => {
94
+ const count = Number.parseFloat(budget.slice(1));
95
+ if (!/^[rR]./.test(budget) || !Number.isFinite(count) || count <= 0)
96
+ throw new TlaProverError(`Invalid SMT budget "${budget}"`);
97
+ return Math.max(1, Math.trunc(Math.min(count * RLIMIT_BASE, MAX_RLIMIT)));
98
+ };
99
+
100
+ // compute_meth: a group of a pragma's settings, where each @ takes the next argument the pragma is
101
+ // applied to.
102
+ const computeMethod = (settings: PragmaSetting[], args: Expr[]): Method => {
103
+ const values = settings.reduce<{
104
+ args: Expr[];
105
+ prover?: string;
106
+ timeout?: number;
107
+ rlimit?: number;
108
+ tactic?: string;
109
+ }>(
110
+ (state, setting) => {
111
+ const value = setting.value;
112
+ const argument = value.kind === "Default" ? state.args[0] : undefined;
113
+ const rest = value.kind === "Default" ? state.args.slice(1) : state.args;
114
+ if (value.kind === "Default" && !argument)
115
+ throw new TlaProverError("Some arguments are missing");
116
+ const text =
117
+ value.kind === "String"
118
+ ? value.value
119
+ : argument?.kind === "String"
120
+ ? argument.value
121
+ : undefined;
122
+ switch (setting.hint) {
123
+ case "prover":
124
+ case "tactic":
125
+ if (text === undefined) throw new TlaProverError(`This argument should be a string`);
126
+ return { ...state, args: rest, [setting.hint]: text };
127
+ case "timeout": {
128
+ if (value.kind === "Float") return { ...state, args: rest, timeout: value.value };
129
+ if (text !== undefined) return { ...state, args: rest, rlimit: getRlimit(text) };
130
+ if (argument?.kind !== "Num")
131
+ throw new TlaProverError("This argument should be a number of seconds");
132
+ return {
133
+ ...state,
134
+ args: rest,
135
+ timeout: Number(`${argument.integer}.${argument.fraction}`),
136
+ };
137
+ }
138
+ default:
139
+ throw new TlaProverError(`Unknown keyword in proof method definition: ${setting.hint}`);
140
+ }
141
+ },
142
+ { args },
143
+ );
144
+ if (values.args.length > 0) throw new TlaProverError("Too many arguments");
145
+ if (values.prover === undefined) throw new TlaProverError("Missing prover name");
146
+ return getProverMethod(values.prover, values.timeout, values.rlimit, values.tactic);
147
+ };
148
+
149
+ // An old-style method, as Method_prs reads it, with its default time unless it names one.
150
+ const getOldMethod = (method: OldMethod) =>
151
+ getProverMethod(method.name, method.timeout, undefined, method.tactic);
152
+
153
+ type Cited =
154
+ | { kind: "Premeth"; groups: PragmaSetting[][] }
155
+ | { kind: "Meth"; method: OldMethod }
156
+ | undefined;
157
+
158
+ // find_meth: an obligation whose proof names a method keeps it. Otherwise each visible fact that
159
+ // cites a pragma, alone or applied to arguments, adds the methods its groups compute, and each that
160
+ // cites a theorem or carries an old-style method adds that method. A pragma that a fact from
161
+ // another BY or USE cites drops the methods found so far: tlapm compares the USE locations
162
+ // physically, as tla-ts compares the objects.
163
+ const getCitedMethods = (sequent: Sequent) => {
164
+ const cited: Cited[] = [];
165
+ const state: { methods: Method[]; useLocation: Locus | undefined | null } = {
166
+ methods: [],
167
+ useLocation: null,
168
+ };
169
+ sequent.context.forEach((hyp, index) => {
170
+ const expression = hyp.kind === "Fact" && hyp.visibility === "Visible" && hyp.expression;
171
+ if (expression && expression.kind === "With") {
172
+ state.methods.push(getOldMethod(expression.method));
173
+ cited.push(undefined);
174
+ return;
175
+ }
176
+ if (hyp.kind === "Defn" && hyp.definition.kind === "Bpragma") {
177
+ cited.push({ kind: "Premeth", groups: hyp.definition.methods });
178
+ return;
179
+ }
180
+ if (hyp.kind === "Defn" && hyp.definition.kind === "Operator" && hyp.visibility === "Visible") {
181
+ const body = hyp.definition.body;
182
+ cited.push(body.kind === "With" ? { kind: "Meth", method: body.method } : undefined);
183
+ return;
184
+ }
185
+ cited.push(undefined);
186
+ if (!expression || hyp.kind !== "Fact") return;
187
+ const operator = expression.kind === "Apply" ? expression.operator : expression;
188
+ if (operator.kind !== "Ix") return;
189
+ const entry = cited[index - operator.index];
190
+ if (entry?.kind === "Premeth") {
191
+ if (hyp.useLocation !== state.useLocation) {
192
+ state.methods = [];
193
+ state.useLocation = hyp.useLocation;
194
+ }
195
+ const args = expression.kind === "Apply" ? expression.args : [];
196
+ state.methods.push(...entry.groups.map((group) => computeMethod(group, args)));
197
+ return;
198
+ }
199
+ if (entry?.kind !== "Meth") return;
200
+ // find_meth asserts that a theorem with a method is not applied to arguments.
201
+ if (expression.kind === "Apply") throw new TlapmBugError();
202
+ state.methods.push(getOldMethod(entry.method));
203
+ });
204
+ return state.methods;
205
+ };
206
+
207
+ // The methods find_meth selects: the frontends to apply, and the provers to try in order, which
208
+ // are tlapm's default ones when the obligation cites only frontends or nothing.
209
+ export const findMethods = (obligation: { sequent: Sequent; method?: OldMethod }) => {
210
+ const methods =
211
+ obligation.method === undefined
212
+ ? getCitedMethods(obligation.sequent)
213
+ : [getOldMethod(obligation.method)];
214
+ const provers = methods.filter((method) => !FRONTENDS.has(method.prover));
215
+ return {
216
+ frontends: new Set(
217
+ methods.flatMap((method) => (FRONTENDS.has(method.prover) ? [method.prover] : [])),
218
+ ),
219
+ provers: provers.length > 0 ? provers : DEFAULT_METHODS,
220
+ };
221
+ };
@@ -0,0 +1,309 @@
1
+ // What Backend.Prep does to an obligation before a backend's frontend: normalize_expand, which
2
+ // expands definitions, runs Expr.Elab.normalize and the frontend methods the obligation cites, then
3
+ // trivial and flatten.
4
+
5
+ import { TlapmBugError, TlaProofError } from "../../errors";
6
+ import { expandActionOperators, lambdify } from "../../obligations/action";
7
+ import { createAnonymizer } from "../../obligations/anonymize";
8
+ import { isEqualExpr } from "../../obligations/equality";
9
+ import {
10
+ applyBuiltin,
11
+ at,
12
+ createContextMap,
13
+ getChildren,
14
+ mapChildren,
15
+ mapExceptSpecs,
16
+ mapHyp,
17
+ type Bound,
18
+ type ExceptPoint,
19
+ type Expr,
20
+ type Hyp,
21
+ type Sequent,
22
+ } from "../../obligations/expression";
23
+ import {
24
+ bumpBy,
25
+ consSubstitution,
26
+ shift,
27
+ shiftExpr,
28
+ substituteExpr,
29
+ substituteHyp,
30
+ type Substitution,
31
+ } from "../../obligations/substitution";
32
+ import type { OldMethod } from "../../obligations/pragma";
33
+ import { implicationToEnabled } from "./enabled-axioms";
34
+ import { checkLevelChange } from "./level-comparison";
35
+ import { findMethods } from "./methods";
36
+
37
+ const createDefinitionExpander = (isPragmaExpanded: boolean) =>
38
+ createContextMap(shift(0), (current, hyp) => {
39
+ if (
40
+ hyp.kind === "Defn" &&
41
+ ((isPragmaExpanded && hyp.definition.kind === "Bpragma") ||
42
+ (hyp.definition.kind === "Operator" && hyp.visibility === "Visible"))
43
+ ) {
44
+ return [consSubstitution(substituteExpr(current, hyp.definition.body), current), undefined];
45
+ }
46
+ return [bumpBy(1, current), substituteHyp(current, hyp)];
47
+ });
48
+
49
+ const expandDefinitionsAndPragmas = createDefinitionExpander(true);
50
+
51
+ const expandDefinitions = createDefinitionExpander(false);
52
+
53
+ // expand_defs: each visible operator definition and each pragma, whatever its visibility,
54
+ // substitutes into the rest of the obligation and leaves the context. Toolbox.expand_defs leaves
55
+ // the pragmas.
56
+ export const expandDefs = (sequent: Sequent, isPragmaExpanded = true): Sequent => {
57
+ const expanded = (isPragmaExpanded ? expandDefinitionsAndPragmas : expandDefinitions)(
58
+ sequent.context,
59
+ );
60
+ return { context: expanded.context, active: substituteExpr(expanded.state, sequent.active) };
61
+ };
62
+
63
+ type ExceptSpec = Extract<Expr, { kind: "Except" }>["specs"][number];
64
+
65
+ const TEMPORAL_BUILTINS = new Set(["BoxTrue", "BoxFalse", "Diamond", "Actplus", "Leadsto", "Cdot"]);
66
+
67
+ // The expressions of a hypothesis that Visit.iter visits, none for a hidden one.
68
+ const getVisitedExprs = (hyp: Hyp): Expr[] => {
69
+ switch (hyp.kind) {
70
+ case "Fresh":
71
+ return hyp.domain ? [hyp.domain] : [];
72
+ case "Flex":
73
+ return [];
74
+ case "Defn":
75
+ return hyp.visibility === "Hidden" ||
76
+ (hyp.definition.kind !== "Operator" && hyp.definition.kind !== "Bpragma")
77
+ ? []
78
+ : [hyp.definition.body];
79
+ case "Fact":
80
+ return hyp.visibility === "Hidden" ? [] : [hyp.expression];
81
+ }
82
+ };
83
+
84
+ // Elab.non_temporal: no temporal operator, but in hidden hypotheses.
85
+ const isNonTemporal = (expression: Expr): boolean => {
86
+ if (expression.kind === "Tsub" || expression.kind === "Fair") return false;
87
+ if (
88
+ expression.kind === "Apply" &&
89
+ expression.operator.kind === "Internal" &&
90
+ TEMPORAL_BUILTINS.has(expression.operator.builtin)
91
+ )
92
+ return false;
93
+ if (expression.kind === "Sequent") {
94
+ const sequent = expression.sequent;
95
+ return [...sequent.context.flatMap(getVisitedExprs), sequent.active].every(isNonTemporal);
96
+ }
97
+ return getChildren(expression).every(isNonTemporal);
98
+ };
99
+
100
+ // Elab.let_normalize: each LET definition is substituted into the rest of the LET.
101
+ const normalizeLet = (expression: Expr): Expr => {
102
+ if (expression.kind !== "Let") return mapChildren(expression, normalizeLet);
103
+ const [definition, ...definitions] = expression.definitions;
104
+ if (!definition) return normalizeLet(expression.body);
105
+ if (definition.kind !== "Operator" && definition.kind !== "Bpragma") {
106
+ throw new TlaProofError(
107
+ definition.kind === "Instance"
108
+ ? "Found INSTANCE in Expr.Elab.let_normalize, all INSTANCE statements have been replaced with definitions in Module.Elab "
109
+ : "Expr.Elab.let_normalize",
110
+ );
111
+ }
112
+ const operator = normalizeLet(definition.body);
113
+ const rest: Expr = { ...expression, definitions };
114
+ return normalizeLet(substituteExpr(consSubstitution(operator, shift(0)), rest));
115
+ };
116
+
117
+ const getAccess = (base: Expr, point: ExceptPoint): Expr =>
118
+ point.kind === "Dot"
119
+ ? at({ kind: "Dot", expression: base, field: point.field }, base)
120
+ : at({ kind: "FcnApp", function: base, args: [point.expression] }, base);
121
+
122
+ const isSameHead = (left: ExceptPoint, right: ExceptPoint) =>
123
+ left.kind === "Dot"
124
+ ? right.kind === "Dot" && left.field === right.field
125
+ : right.kind === "Apply" && isEqualExpr(left.expression, right.expression);
126
+
127
+ // The field of a record constructor that a point names, as a field or as a string argument.
128
+ const getRecordField = (record: Expr, point: ExceptPoint) => {
129
+ const name =
130
+ point.kind === "Dot"
131
+ ? point.field
132
+ : point.expression.kind === "String"
133
+ ? point.expression.value
134
+ : undefined;
135
+ return record.kind === "Record" && name !== undefined
136
+ ? record.fields.find((field) => field.name === name)
137
+ : undefined;
138
+ };
139
+
140
+ // Elab.except_normalize: [f EXCEPT p1 = b1, ...] folds left to right into f, sharing each prefix of
141
+ // adjacent updates and updating a record constructor in place on a field it has.
142
+ const normalizeExcept = (expression: Expr): Expr => {
143
+ if (expression.kind !== "Except") return mapChildren(expression, normalizeExcept);
144
+ const except = expression;
145
+ const select = (base: Expr, point: ExceptPoint) =>
146
+ getRecordField(base, point)?.value ?? getAccess(base, point);
147
+ const update = (base: Expr, point: ExceptPoint, value: Expr): Expr => {
148
+ const field = getRecordField(base, point);
149
+ if (base.kind !== "Record" || !field)
150
+ return at({ kind: "Except", function: base, specs: [{ trail: [point], value }] }, except);
151
+ const fields = base.fields.map((entry) =>
152
+ entry.name === field.name ? { name: entry.name, value } : entry,
153
+ );
154
+ return at({ kind: "Record", fields }, base);
155
+ };
156
+ const apply = (base: Expr, specs: ExceptSpec[]): Expr => {
157
+ const [first, ...others] = specs;
158
+ if (!first) return base;
159
+ if (first.trail.length === 0) return apply(first.value, others);
160
+ const head = first.trail[0];
161
+ const end = specs.findIndex(
162
+ (spec) => spec.trail.length === 0 || !isSameHead(spec.trail[0], head),
163
+ );
164
+ const count = end === -1 ? specs.length : end;
165
+ const tails = specs
166
+ .slice(0, count)
167
+ .map((spec) => ({ trail: spec.trail.slice(1), value: spec.value }));
168
+ return apply(update(base, head, apply(select(base, head), tails)), specs.slice(count));
169
+ };
170
+ return apply(normalizeExcept(except.function), mapExceptSpecs(except.specs, normalizeExcept));
171
+ };
172
+
173
+ // let_normalize on each hypothesis, and whether the context so far is non_temporal.
174
+ const normalizeLetContext = createContextMap(true, (isContextNonTemporal, hyp) => [
175
+ isContextNonTemporal && getVisitedExprs(hyp).every(isNonTemporal),
176
+ mapHyp(hyp, normalizeLet, "all"),
177
+ ]);
178
+
179
+ const normalizeExceptContext = createContextMap(undefined, (_state, hyp) => [
180
+ undefined,
181
+ mapHyp(hyp, normalizeExcept, "all"),
182
+ ]);
183
+
184
+ // Elab.normalize, on an obligation as a sequent expression, as Prep.normalize_expr calls it: LET
185
+ // definitions inline, and the updates of an EXCEPT fold into the function they update.
186
+ export const normalizeSequent = (sequent: Sequent): Sequent => {
187
+ const inlined = normalizeLetContext(sequent.context);
188
+ const active = normalizeLet(sequent.active);
189
+ return inlined.state && isNonTemporal(sequent.active)
190
+ ? {
191
+ context: normalizeExceptContext(sequent.context, inlined.context).context,
192
+ active: normalizeExcept(active),
193
+ }
194
+ : { context: inlined.context, active };
195
+ };
196
+
197
+ // expand_enabled_cdot: the first frontend the methods cite, in tlapm's order, transforms the
198
+ // obligation. Its soundness checks throw a TlaProverError, as tlapm then runs no backend.
199
+ const expandEnabledCdot = (sequent: Sequent, frontends: Set<string>): Sequent => {
200
+ const isEnabled = frontends.has("expandenabled");
201
+ const isCdot = frontends.has("expandcdot");
202
+ const isAutoUse = frontends.has("autouse");
203
+ const isLambdify = frontends.has("lambdify");
204
+ if (!isEnabled && !isCdot && !isLambdify) {
205
+ if (frontends.has("levelcomparison")) return checkLevelChange(sequent);
206
+ if (frontends.has("enabledaxioms")) return implicationToEnabled(sequent);
207
+ return sequent;
208
+ }
209
+ // Expr.Anon's anon, which only meets the names that lambdification binds.
210
+ const anonymizer = createAnonymizer(
211
+ { value: 0 },
212
+ () => {
213
+ throw new TlapmBugError();
214
+ },
215
+ () => {},
216
+ );
217
+ const expression: Expr = { kind: "Sequent", sequent };
218
+ const result =
219
+ isEnabled || isCdot
220
+ ? expandActionOperators(anonymizer, () => {}, undefined, expression, {
221
+ isEnabled,
222
+ isCdot,
223
+ isAutoUse,
224
+ })
225
+ : lambdify(anonymizer, () => {}, undefined, expression, {
226
+ isEnabled: true,
227
+ isCdot: true,
228
+ isAutoUse,
229
+ });
230
+ if (result.kind !== "Sequent") throw new TlapmBugError();
231
+ return result.sequent;
232
+ };
233
+
234
+ // normalize_expand: expand_defs, Elab.normalize, then the frontends the obligation cites.
235
+ export const normalizeExpand = (
236
+ obligation: { sequent: Sequent; method?: OldMethod },
237
+ methods = findMethods(obligation),
238
+ ) => expandEnabledCdot(normalizeSequent(expandDefs(obligation.sequent)), methods.frontends);
239
+
240
+ // trivial: the goal is TRUE, or find_fact finds it as a hypothesis, visible or not: a fact
241
+ // alpha-equivalent to it, or the x \in S of a declaration NEW x \in S.
242
+ export const isTrivial = (sequent: Sequent) =>
243
+ (sequent.active.kind === "Internal" && sequent.active.builtin === "TRUE") ||
244
+ sequent.context.some((hyp, index) => {
245
+ if (hyp.kind === "Fact")
246
+ return isEqualExpr(hyp.expression, shiftExpr(index - sequent.context.length, sequent.active));
247
+ if (hyp.kind !== "Fresh" || !hyp.domain) return false;
248
+ return isEqualExpr(
249
+ applyBuiltin("Mem", [{ kind: "Ix", index: 1 }, shiftExpr(1, hyp.domain)], {}),
250
+ shiftExpr(index + 1 - sequent.context.length, sequent.active),
251
+ );
252
+ });
253
+
254
+ const isUnbounded = (bound: Bound) => bound.domain.kind === "NoDomain";
255
+
256
+ // extract_equalities: the equalities in a conjunction, apart from the rest of it.
257
+ const extractEqualities = (expression: Expr): [Expr[], Expr | undefined] => {
258
+ if (expression.kind === "List" && (expression.bullet === "And" || expression.bullet === "Refs")) {
259
+ const parts = expression.items.map(extractEqualities);
260
+ const equalities = parts.flatMap((part) => part[0]);
261
+ const rest = parts.flatMap((part) => (part[1] ? [part[1]] : []));
262
+ if (rest.length <= 1) return [equalities, rest[0]];
263
+ return [equalities, { ...expression, bullet: "And", items: rest }];
264
+ }
265
+ if (expression.kind === "Apply" && expression.operator.kind === "Internal") {
266
+ const builtin = expression.operator.builtin;
267
+ if (builtin === "Conj" && expression.args.length === 2) {
268
+ const left = extractEqualities(expression.args[0]);
269
+ const right = extractEqualities(expression.args[1]);
270
+ const equalities = [...left[0], ...right[0]];
271
+ if (left[1] && right[1]) return [equalities, { ...expression, args: [left[1], right[1]] }];
272
+ return [equalities, left[1] ?? right[1]];
273
+ }
274
+ if (builtin === "Eq") return [[expression], undefined];
275
+ }
276
+ if (expression.kind === "Internal" && expression.builtin === "TRUE") return [[], undefined];
277
+ if (
278
+ expression.kind === "Quant" &&
279
+ expression.quantifier === "Forall" &&
280
+ expression.bounds.every(isUnbounded)
281
+ ) {
282
+ const extracted = extractEqualities(expression.body);
283
+ const quantify = (inner: Expr, from: Expr) =>
284
+ at({ kind: "Quant", quantifier: "Forall", bounds: expression.bounds, body: inner }, from);
285
+ return [
286
+ extracted[0].map((equality) => quantify(equality, equality)),
287
+ extracted[1] && quantify(extracted[1], expression),
288
+ ];
289
+ }
290
+ return [[], expression];
291
+ };
292
+
293
+ // flatten: each visible fact becomes the rest of it, then its equalities.
294
+ export const flatten = (sequent: Sequent): Sequent => {
295
+ const context: Hyp[] = [];
296
+ const substitution = sequent.context.reduce<Substitution>((current, hyp) => {
297
+ if (hyp.kind !== "Fact" || hyp.visibility !== "Visible") {
298
+ context.push(substituteHyp(current, hyp));
299
+ return bumpBy(1, current);
300
+ }
301
+ const extracted = extractEqualities(hyp.expression);
302
+ const facts = [...(extracted[1] ? [extracted[1]] : []), ...extracted[0]];
303
+ facts.forEach((fact, index) =>
304
+ context.push({ ...hyp, expression: shiftExpr(index, substituteExpr(current, fact)) }),
305
+ );
306
+ return { kind: "Compose", outer: shift(facts.length - 1), inner: bumpBy(1, current) };
307
+ }, shift(0));
308
+ return { context, active: substituteExpr(substitution, sequent.active) };
309
+ };
@@ -0,0 +1,22 @@
1
+ // A worker of the decide pool: it decides each request with the backend its prover selects.
2
+
3
+ import { TlaProverError } from "../errors";
4
+ import { getParentPort } from "../worker";
5
+ import { decide } from "./deciders";
6
+ import type { DecideRequest, DecideResponse } from "./decide-pool";
7
+
8
+ const getResponse = (request: DecideRequest): DecideResponse => {
9
+ try {
10
+ return decide(request.prover, request.text, { timeLimitMs: request.timeLimitMs });
11
+ } catch (error) {
12
+ if (error instanceof TlaProverError) return { error: error.message };
13
+ throw error;
14
+ }
15
+ };
16
+
17
+ void getParentPort().then((parent) => {
18
+ parent.addEventListener("message", (event) =>
19
+ parent.postMessage(getResponse(event.data as DecideRequest)),
20
+ );
21
+ parent.start?.();
22
+ });