tla-ts 0.0.4-dev.a297123 → 0.0.4-dev.e92649a

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 (311) hide show
  1. package/README.md +26 -141
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +35 -1
  6. package/dist/index.d.ts +35 -1
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -4
  9. package/dist/parallel-worker.js +1 -4
  10. package/dist/prove-worker.cjs +9 -0
  11. package/dist/prove-worker.d.cts +9 -0
  12. package/dist/prove-worker.d.ts +9 -0
  13. package/dist/prove-worker.js +9 -0
  14. package/dist/prove.cjs +515 -0
  15. package/dist/prove.js +515 -0
  16. package/dist/run-cli.cjs +30 -47
  17. package/dist/run-cli.js +30 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/check.ts +1 -0
  26. package/src/codegen.ts +5 -3
  27. package/src/errors.ts +86 -0
  28. package/src/evaluate.ts +54 -19
  29. package/src/index.ts +10 -0
  30. package/src/{obligation-action.ts → obligations/action.ts} +258 -37
  31. package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
  32. package/src/obligations/ctx.ts +64 -0
  33. package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
  34. package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
  35. package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
  36. package/src/{obligations.ts → obligations/index.ts} +26 -12
  37. package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
  38. package/src/{obligation-module.ts → obligations/module.ts} +46 -20
  39. package/src/obligations/pickle.ts +100 -0
  40. package/src/obligations/pragma.ts +189 -0
  41. package/src/{obligation-printer.ts → obligations/printer.ts} +5 -59
  42. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  43. package/src/{obligation-source.ts → obligations/source.ts} +91 -35
  44. package/src/obligations/temporal.ts +319 -0
  45. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  46. package/src/parallel-worker.ts +2 -18
  47. package/src/parallel.ts +10 -43
  48. package/src/prove/decide-pool.ts +100 -0
  49. package/src/prove/deciders.ts +27 -0
  50. package/src/prove/isabelle/LICENSE +36 -0
  51. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  52. package/src/prove/isabelle/decide.ts +47 -0
  53. package/src/prove/isabelle/encode.ts +477 -0
  54. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  55. package/src/prove/isabelle/isar/method.ts +367 -0
  56. package/src/prove/isabelle/isar/proof.ts +28 -0
  57. package/src/prove/isabelle/isar/statement.ts +57 -0
  58. package/src/prove/isabelle/isar/theory.ts +192 -0
  59. package/src/prove/isabelle/isar/type-check.ts +278 -0
  60. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  61. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  62. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  63. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  64. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  65. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  66. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  67. package/src/prove/isabelle/provers/classical.ts +389 -0
  68. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  69. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  70. package/src/prove/isabelle/pure/consts.ts +32 -0
  71. package/src/prove/isabelle/pure/conv.ts +79 -0
  72. package/src/prove/isabelle/pure/drule.ts +264 -0
  73. package/src/prove/isabelle/pure/envir.ts +363 -0
  74. package/src/prove/isabelle/pure/goal.ts +53 -0
  75. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  76. package/src/prove/isabelle/pure/list.ts +12 -0
  77. package/src/prove/isabelle/pure/logic.ts +402 -0
  78. package/src/prove/isabelle/pure/name.ts +110 -0
  79. package/src/prove/isabelle/pure/net.ts +262 -0
  80. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  81. package/src/prove/isabelle/pure/pattern.ts +650 -0
  82. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  83. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  84. package/src/prove/isabelle/pure/search.ts +68 -0
  85. package/src/prove/isabelle/pure/seq.ts +156 -0
  86. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  87. package/src/prove/isabelle/pure/table.ts +208 -0
  88. package/src/prove/isabelle/pure/tactic.ts +276 -0
  89. package/src/prove/isabelle/pure/tactical.ts +347 -0
  90. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  91. package/src/prove/isabelle/pure/term.ts +808 -0
  92. package/src/prove/isabelle/pure/thm.ts +806 -0
  93. package/src/prove/isabelle/pure/type.ts +133 -0
  94. package/src/prove/isabelle/pure/unify.ts +753 -0
  95. package/src/prove/isabelle/pure/variable.ts +25 -0
  96. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  97. package/src/prove/isabelle/tla/context.ts +74 -0
  98. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  99. package/src/prove/isabelle/tla/logic.ts +215 -0
  100. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  101. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  102. package/src/prove/ocaml.ts +22 -0
  103. package/src/prove/prep/action.ts +520 -0
  104. package/src/prove/prep/defs.ts +27 -0
  105. package/src/prove/prep/elab.ts +156 -0
  106. package/src/prove/prep/enabled-axioms.ts +189 -0
  107. package/src/prove/prep/enabled.ts +43 -0
  108. package/src/prove/prep/fingerprint.ts +388 -0
  109. package/src/prove/prep/flatten.ts +70 -0
  110. package/src/prove/prep/level-comparison.ts +552 -0
  111. package/src/prove/prep/md5.ts +67 -0
  112. package/src/prove/prep/pragma.ts +221 -0
  113. package/src/prove/prep/trivial.ts +22 -0
  114. package/src/prove/prove-worker.ts +29 -0
  115. package/src/prove/prove.ts +417 -0
  116. package/src/prove/ptl/decide.ts +68 -0
  117. package/src/prove/ptl/encode.ts +256 -0
  118. package/src/prove/ptl/sat.ts +151 -0
  119. package/src/prove/ptl/tableau.ts +276 -0
  120. package/src/prove/smt/axiomatize.ts +69 -0
  121. package/src/prove/smt/axioms.ts +210 -0
  122. package/src/prove/smt/context.ts +108 -0
  123. package/src/prove/smt/data.ts +665 -0
  124. package/src/prove/smt/encode.ts +169 -0
  125. package/src/prove/smt/extensionality.ts +63 -0
  126. package/src/prove/smt/flatten.ts +127 -0
  127. package/src/prove/smt/format.ts +143 -0
  128. package/src/prove/smt/instances.ts +182 -0
  129. package/src/prove/smt/rewrite.ts +784 -0
  130. package/src/prove/smt/simplify.ts +57 -0
  131. package/src/prove/smt/solver/act-cache.ts +265 -0
  132. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  133. package/src/prove/smt/solver/array.ts +22 -0
  134. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  135. package/src/prove/smt/solver/ast-lt.ts +157 -0
  136. package/src/prove/smt/solver/ast-util.ts +147 -0
  137. package/src/prove/smt/solver/ast.ts +1315 -0
  138. package/src/prove/smt/solver/auf-solver.ts +572 -0
  139. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  140. package/src/prove/smt/solver/cg-table.ts +175 -0
  141. package/src/prove/smt/solver/clause.ts +276 -0
  142. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  143. package/src/prove/smt/solver/context.ts +1292 -0
  144. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  145. package/src/prove/smt/solver/der.ts +224 -0
  146. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  147. package/src/prove/smt/solver/e-matching.ts +659 -0
  148. package/src/prove/smt/solver/enode.ts +259 -0
  149. package/src/prove/smt/solver/expr-ref.ts +21 -0
  150. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  151. package/src/prove/smt/solver/fingerprints.ts +92 -0
  152. package/src/prove/smt/solver/flat-literals.ts +51 -0
  153. package/src/prove/smt/solver/goal.ts +138 -0
  154. package/src/prove/smt/solver/hash.ts +173 -0
  155. package/src/prove/smt/solver/hashtable.ts +166 -0
  156. package/src/prove/smt/solver/internalizer.ts +1381 -0
  157. package/src/prove/smt/solver/lbool.ts +5 -0
  158. package/src/prove/smt/solver/literal.ts +24 -0
  159. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  160. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  161. package/src/prove/smt/solver/lp/containers.ts +296 -0
  162. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  163. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  164. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  165. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  166. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  167. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  168. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  169. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  170. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  171. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  172. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  173. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  174. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  175. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  176. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  177. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  178. package/src/prove/smt/solver/lp/nex.ts +120 -0
  179. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  180. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  181. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  182. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  183. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  184. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  185. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  186. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  187. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  188. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  189. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  190. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  191. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  192. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  193. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  194. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  195. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  196. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  197. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  198. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  199. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  200. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  201. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  202. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  203. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  204. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  205. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  206. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  207. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  208. package/src/prove/smt/solver/model-checker.ts +347 -0
  209. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  210. package/src/prove/smt/solver/model-finder.ts +155 -0
  211. package/src/prove/smt/solver/model-generator.ts +97 -0
  212. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  213. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  214. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  215. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  216. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  217. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  218. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  219. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  220. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  221. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  222. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  223. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  224. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  225. package/src/prove/smt/solver/nnf.ts +469 -0
  226. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  227. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  228. package/src/prove/smt/solver/propagate-values.ts +83 -0
  229. package/src/prove/smt/solver/proto-model.ts +551 -0
  230. package/src/prove/smt/solver/pull-quant.ts +139 -0
  231. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  232. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  233. package/src/prove/smt/solver/qe-lite.ts +381 -0
  234. package/src/prove/smt/solver/qi-queue.ts +362 -0
  235. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  236. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  237. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  238. package/src/prove/smt/solver/random-gen.ts +10 -0
  239. package/src/prove/smt/solver/rational.ts +165 -0
  240. package/src/prove/smt/solver/ref-vector.ts +62 -0
  241. package/src/prove/smt/solver/relevancy.ts +247 -0
  242. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  243. package/src/prove/smt/solver/rewriter.ts +843 -0
  244. package/src/prove/smt/solver/rlimit.ts +79 -0
  245. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  246. package/src/prove/smt/solver/solver.ts +71 -0
  247. package/src/prove/smt/solver/sort.ts +35 -0
  248. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  249. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  250. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  251. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  252. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  253. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  254. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  255. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  256. package/src/prove/smt/solver/theory-lra.ts +56 -0
  257. package/src/prove/smt/solver/var-subst.ts +258 -0
  258. package/src/prove/smt/solver/z3-license.txt +10 -0
  259. package/src/prove/smt/table.ts +170 -0
  260. package/src/prove/tlapm/tlapm.ts +96 -0
  261. package/src/prove/tlaps-module.ts +510 -0
  262. package/src/prove/verdict.ts +13 -0
  263. package/src/prove/zenon/LICENSE +32 -0
  264. package/src/prove/zenon/check/check.ts +105 -0
  265. package/src/prove/zenon/check/definitions.ts +144 -0
  266. package/src/prove/zenon/check/equality.ts +182 -0
  267. package/src/prove/zenon/check/functions.ts +62 -0
  268. package/src/prove/zenon/check/keys.ts +125 -0
  269. package/src/prove/zenon/check/propositional.ts +104 -0
  270. package/src/prove/zenon/check/records.ts +188 -0
  271. package/src/prove/zenon/check/relations.ts +121 -0
  272. package/src/prove/zenon/check/rewrites.ts +224 -0
  273. package/src/prove/zenon/check/sets.ts +302 -0
  274. package/src/prove/zenon/check/terms.ts +127 -0
  275. package/src/prove/zenon/check/tla.ts +126 -0
  276. package/src/prove/zenon/decide.ts +113 -0
  277. package/src/prove/zenon/encode.ts +444 -0
  278. package/src/prove/zenon/eqrel.ts +300 -0
  279. package/src/prove/zenon/equality-rules.ts +435 -0
  280. package/src/prove/zenon/expr.ts +551 -0
  281. package/src/prove/zenon/index-table.ts +350 -0
  282. package/src/prove/zenon/isar-case.ts +513 -0
  283. package/src/prove/zenon/isar.ts +1249 -0
  284. package/src/prove/zenon/limits.ts +15 -0
  285. package/src/prove/zenon/llproof.ts +173 -0
  286. package/src/prove/zenon/mltoll.ts +1566 -0
  287. package/src/prove/zenon/node.ts +297 -0
  288. package/src/prove/zenon/ocaml.ts +169 -0
  289. package/src/prove/zenon/parse.ts +247 -0
  290. package/src/prove/zenon/phrase.ts +191 -0
  291. package/src/prove/zenon/proof.ts +198 -0
  292. package/src/prove/zenon/propositional-rules.ts +387 -0
  293. package/src/prove/zenon/rules.ts +94 -0
  294. package/src/prove/zenon/search.ts +288 -0
  295. package/src/prove/zenon/tla/functions.ts +151 -0
  296. package/src/prove/zenon/tla/llproof.ts +480 -0
  297. package/src/prove/zenon/tla/records.ts +225 -0
  298. package/src/prove/zenon/tla/rewrites.ts +447 -0
  299. package/src/prove/zenon/tla/sets.ts +304 -0
  300. package/src/prove/zenon/tla/terms.ts +181 -0
  301. package/src/prove/zenon/tla/tla.ts +506 -0
  302. package/src/run-cli.ts +73 -20
  303. package/src/standard-modules.ts +5 -2
  304. package/src/successors.ts +24 -5
  305. package/src/tlc-random.ts +55 -32
  306. package/src/tlc-version.ts +8 -7
  307. package/src/values.ts +80 -35
  308. package/src/worker.ts +65 -0
  309. package/dist/parallel.cjs +0 -12
  310. package/dist/parallel.js +0 -12
  311. /package/src/{obligation-format.ts → obligations/format.ts} +0 -0
@@ -0,0 +1,506 @@
1
+ // Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
2
+ //
3
+ // The TLA+ extension: rules for set theory, functions, records, tuples, CHOOSE, IF and CASE, and
4
+ // rewriting a subterm with an equality on the branch.
5
+
6
+ import {
7
+ FALSE,
8
+ isApp,
9
+ TRUE,
10
+ type Expr,
11
+ type Expressions,
12
+ type NegatedRelationExpr,
13
+ type RelationExpr,
14
+ } from "../expr";
15
+ import type { Node, Priority } from "../node";
16
+ import type { Phrase } from "../parse";
17
+ import { makeRule, type Rule } from "../proof";
18
+ import { getFunctionNodes, getFunctionSetNodes } from "./functions";
19
+ import { getRecordNodes, getTupleNodes } from "./records";
20
+ import { getRewriteNodes } from "./rewrites";
21
+ import {
22
+ getMembershipNodes,
23
+ getMetaMembershipNodes,
24
+ getSetEqualityNodes,
25
+ getSubsetNodes,
26
+ } from "./sets";
27
+ import {
28
+ equal,
29
+ FUNCTION_CONSTRUCTORS,
30
+ getLiteral,
31
+ isNotEquiv,
32
+ isVariable,
33
+ makeExtensionNode,
34
+ makeInstanceNode,
35
+ member,
36
+ SET_CONSTRUCTORS,
37
+ type Item,
38
+ type Literal,
39
+ type TlaContext,
40
+ } from "./terms";
41
+
42
+ const OTHER_SYMBOLS = [
43
+ "TLA.in",
44
+ "TLA.isAFcn",
45
+ "TLA.cond",
46
+ "TLA.CASE",
47
+ "TLA.tuple",
48
+ "TLA.record",
49
+ "TLA.fapply",
50
+ "TLA.box",
51
+ ];
52
+
53
+ // The symbols that hypotheses can't define, as Zenon's predef with the tla extension.
54
+ export const PREDEFINED_SYMBOLS = [
55
+ "=",
56
+ ...SET_CONSTRUCTORS,
57
+ ...FUNCTION_CONSTRUCTORS,
58
+ ...OTHER_SYMBOLS,
59
+ ];
60
+
61
+ const definition = (
62
+ exprs: Expressions,
63
+ name: string,
64
+ symbol: string,
65
+ params: string[],
66
+ body: Expr,
67
+ ): Phrase => ({
68
+ kind: "def",
69
+ definition: {
70
+ kind: "real",
71
+ name,
72
+ symbol,
73
+ params: params.map((param) => exprs.evar(param)),
74
+ body,
75
+ },
76
+ });
77
+
78
+ // Zenon's built_in_defs. Expressions belong to one run of the prover, so each run builds them.
79
+ export const getBuiltInDefinitions = (exprs: Expressions): Phrase[] => {
80
+ const bound = exprs.evar("x");
81
+ const isInSet = exprs.eapp("TLA.in", [bound, exprs.evar("S")]);
82
+ const holds = exprs.eapp("P", [bound]);
83
+ return [
84
+ definition(
85
+ exprs,
86
+ "subset_def",
87
+ "TLA.subseteq",
88
+ ["A", "B"],
89
+ exprs.eapp("TLA.bAll", [
90
+ exprs.evar("A"),
91
+ exprs.elam(bound, "", exprs.eapp("TLA.in", [bound, exprs.evar("B")])),
92
+ ]),
93
+ ),
94
+ definition(
95
+ exprs,
96
+ "bAll_def",
97
+ "TLA.bAll",
98
+ ["S", "P"],
99
+ exprs.eall(bound, "", exprs.eimply(isInSet, holds)),
100
+ ),
101
+ definition(
102
+ exprs,
103
+ "bEx_def",
104
+ "TLA.bEx",
105
+ ["S", "P"],
106
+ exprs.eex(bound, "", exprs.eand(isInSet, holds)),
107
+ ),
108
+ definition(
109
+ exprs,
110
+ "bChoose_def",
111
+ "TLA.bChoice",
112
+ ["S", "P"],
113
+ exprs.etau(bound, "", exprs.eand(isInSet, holds)),
114
+ ),
115
+ definition(
116
+ exprs,
117
+ "prod_def",
118
+ "TLA.prod",
119
+ ["A", "B"],
120
+ exprs.eapp("TLA.Product", [exprs.eapp("TLA.tuple", [exprs.evar("A"), exprs.evar("B")])]),
121
+ ),
122
+ ];
123
+ };
124
+
125
+ // The elements of a set given by enumeration, and whether it may hold more.
126
+ const getSetValues = (set: Expr): [Expr[], boolean] => {
127
+ if (isVariable(set, "TLA.emptyset")) return [[], false];
128
+ if (isApp(set, "TLA.upair", 2)) return [set.args, false];
129
+ if (isApp(set, "TLA.set")) return [set.args, false];
130
+ if (isApp(set, "TLA.addElt", 2)) {
131
+ const rest = getSetValues(set.args[1]);
132
+ return [[set.args[0], ...rest[0]], rest[1]];
133
+ }
134
+ if (isApp(set, "TLA.union", 2)) {
135
+ const left = getSetValues(set.args[0]);
136
+ const right = getSetValues(set.args[1]);
137
+ return [[...left[0], ...right[0]], left[1] || right[1]];
138
+ }
139
+ return [[], true];
140
+ };
141
+
142
+ const getBooleanNodes = (literal: Literal): Item[] | undefined => {
143
+ const exprs = literal.context.exprs;
144
+ const formula = literal.formula;
145
+ const isNegated = literal.isNegated;
146
+ const atom = literal.atom;
147
+ const relation = literal.relation;
148
+ const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
149
+ makeExtensionNode(literal, priority, rule, branches);
150
+ const instance = (priority: Priority, quantified: Expr, term: Expr) =>
151
+ makeInstanceNode(literal, priority, quantified, term);
152
+ if (atom.kind === "meta") return instance("arity", atom.args[0], isNegated ? TRUE : FALSE);
153
+ if (relation?.symbol !== "=") return undefined;
154
+ const left = relation.args[0];
155
+ const right = relation.args[1];
156
+ if (right.kind === "true")
157
+ return isNegated
158
+ ? node("prop", makeRule("noteq_x_true", [formula, exprs.enot(left), left]), [
159
+ [exprs.enot(left)],
160
+ ])
161
+ : node("prop", makeRule("eq_x_true", [formula, left, left]), [[left]]);
162
+ if (left.kind === "true")
163
+ return isNegated
164
+ ? node("prop", makeRule("noteq_true_x", [formula, exprs.enot(right), right]), [
165
+ [exprs.enot(right)],
166
+ ])
167
+ : node("prop", makeRule("eq_true_x", [formula, right, right]), [[right]]);
168
+ if (!isNegated && right.kind === "false")
169
+ return node("prop", makeRule("eq_x_false", [formula, exprs.enot(left), left]), [
170
+ [exprs.enot(left)],
171
+ ]);
172
+ if (!isNegated && left.kind === "false")
173
+ return node("prop", makeRule("eq_false_x", [formula, exprs.enot(right), right]), [
174
+ [exprs.enot(right)],
175
+ ]);
176
+ return undefined;
177
+ };
178
+
179
+ const getChoiceNodes = (literal: Literal): Item[] | undefined => {
180
+ const exprs = literal.context.exprs;
181
+ const formula = literal.formula;
182
+ const goalness = literal.goalness;
183
+ const isNegated = literal.isNegated;
184
+ const relation = literal.relation;
185
+ const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
186
+ makeExtensionNode(literal, priority, rule, branches);
187
+ if (relation === undefined) return undefined;
188
+ const left = relation.args[0];
189
+ const right = relation.args[1];
190
+ const isEquality = relation.symbol === "=";
191
+ if (
192
+ isNegated &&
193
+ isEquality &&
194
+ left.kind === "tau" &&
195
+ right.kind === "tau" &&
196
+ !isNotEquiv(left.args[1]) &&
197
+ !isNotEquiv(right.args[1])
198
+ ) {
199
+ const bound = exprs.newVar();
200
+ const leftBody = exprs.substitute([[left.args[0], bound]], left.args[1]);
201
+ const rightBody = exprs.substitute([[right.args[0], bound]], right.args[1]);
202
+ const differ = exprs.eex(bound, left.symbol, exprs.eapp("$notequiv", [leftBody, rightBody]));
203
+ return node(
204
+ { instance: differ },
205
+ makeRule("choose_diff_choose", [
206
+ formula,
207
+ differ,
208
+ exprs.elam(left.args[0], left.symbol, left.args[1]),
209
+ exprs.elam(right.args[0], right.symbol, right.args[1]),
210
+ ]),
211
+ [[differ]],
212
+ );
213
+ }
214
+ if (!isNegated && relation.symbol === "$notequiv")
215
+ return node("arity", makeRule("notequivdef", []), [[exprs.enot(exprs.eequiv(left, right))]]);
216
+ const choice = right.kind === "tau" ? right : left.kind === "tau" ? left : undefined;
217
+ if (isNegated && isEquality && choice !== undefined) {
218
+ const term = right.kind === "tau" ? left : right;
219
+ const exists = exprs.eex(choice.args[0], choice.symbol, choice.args[1]);
220
+ const notExists = exprs.enot(exists);
221
+ const notHolds = exprs.enot(exprs.substitute([[choice.args[0], term]], choice.args[1]));
222
+ return [
223
+ {
224
+ conclusions: [],
225
+ rule: makeRule("notequalchoose", [
226
+ exists,
227
+ notExists,
228
+ notHolds,
229
+ exprs.elam(choice.args[0], choice.symbol, choice.args[1]),
230
+ term,
231
+ ]),
232
+ priority: { instance: notExists },
233
+ goalness,
234
+ branches: [[exists], [notExists, notHolds]],
235
+ },
236
+ ];
237
+ }
238
+ return undefined;
239
+ };
240
+
241
+ // The bounded quantifier over an enumerated set in \A x : x \in S => P or ~\E x : x \in S /\ P.
242
+ const getEnumeratedQuantifier = (formula: Expr) => {
243
+ const isEnumerated = (set: Expr) =>
244
+ isVariable(set, "TLA.emptyset") ||
245
+ (set.kind === "app" &&
246
+ ["TLA.addElt", "TLA.upair", "TLA.set", "TLA.union"].includes(set.symbol));
247
+ if (formula.kind === "all") {
248
+ const body = formula.args[1];
249
+ if (
250
+ body.kind === "imply" &&
251
+ isApp(body.args[0], "TLA.in", 2) &&
252
+ isEnumerated(body.args[0].args[1])
253
+ )
254
+ return { quantified: formula, set: body.args[0].args[1] };
255
+ }
256
+ if (formula.kind === "not" && formula.args[0].kind === "ex") {
257
+ const body = formula.args[0].args[1];
258
+ if (
259
+ body.kind === "and" &&
260
+ isApp(body.args[0], "TLA.in", 2) &&
261
+ isEnumerated(body.args[0].args[1])
262
+ )
263
+ return { quantified: formula.args[0], set: body.args[0].args[1] };
264
+ }
265
+ return undefined;
266
+ };
267
+
268
+ const getEnumeratedNodes = (literal: Literal): Item[] | undefined => {
269
+ const formula = literal.formula;
270
+ const instance = (priority: Priority, quantified: Expr, term: Expr) =>
271
+ makeInstanceNode(literal, priority, quantified, term);
272
+ const enumerated = getEnumeratedQuantifier(formula);
273
+ if (enumerated !== undefined) {
274
+ const values = getSetValues(enumerated.set);
275
+ const nodes: Item[] = values[0].flatMap((value) =>
276
+ instance("arity", enumerated.quantified, value),
277
+ );
278
+ return values[1] ? nodes : [...nodes, "stop"];
279
+ }
280
+ return undefined;
281
+ };
282
+
283
+ const getNaturalNodes = (literal: Literal): Item[] | undefined => {
284
+ const exprs = literal.context.exprs;
285
+ const formula = literal.formula;
286
+ const isNegated = literal.isNegated;
287
+ const relation = literal.relation;
288
+ const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
289
+ makeExtensionNode(literal, priority, rule, branches);
290
+ const instance = (priority: Priority, quantified: Expr, term: Expr) =>
291
+ makeInstanceNode(literal, priority, quantified, term);
292
+ if (isNegated && relation?.symbol === "TLA.in" && isVariable(relation.args[1], "arith.N")) {
293
+ const left = relation.args[0];
294
+ if (isVariable(left, "0")) return node("prop", makeRule("in_nat_0", [formula]), []);
295
+ if (isApp(left, "TLA.fapply", 2) && isVariable(left.args[0], "TLA.Succ")) {
296
+ const previous = exprs.enot(member(exprs, left.args[1], exprs.evar("arith.N")));
297
+ return node("prop", makeRule("in_nat_succ", [formula, previous, left.args[1]]), [[previous]]);
298
+ }
299
+ if (left.kind === "meta")
300
+ return instance({ instance: left.args[0] }, left.args[0], exprs.evar("0"));
301
+ }
302
+ return undefined;
303
+ };
304
+
305
+ const getPropNodes = (context: TlaContext, formula: Expr, goalness: number): Item[] => {
306
+ const literal = getLiteral(context, formula, goalness);
307
+ return (
308
+ getBooleanNodes(literal) ??
309
+ getMembershipNodes(literal) ??
310
+ getFunctionSetNodes(literal) ??
311
+ getSetEqualityNodes(literal) ??
312
+ getFunctionNodes(literal) ??
313
+ getChoiceNodes(literal) ??
314
+ getEnumeratedNodes(literal) ??
315
+ getNaturalNodes(literal) ??
316
+ getMetaMembershipNodes(literal) ??
317
+ (!literal.isNegated && isApp(literal.atom, "TLA.box", 1)
318
+ ? makeExtensionNode(literal, "prop", makeRule("box_p", [formula, literal.atom.args[0]]), [
319
+ [literal.atom.args[0]],
320
+ ])
321
+ : undefined) ??
322
+ getTupleNodes(literal) ??
323
+ getRecordNodes(literal) ??
324
+ getSubsetNodes(literal) ??
325
+ []
326
+ );
327
+ };
328
+
329
+ // Zenon's newnodes_inst_bounded: instantiates \A x \in S : P and ~\E x \in S : P with the terms
330
+ // known to be in S.
331
+ const getBoundedInstances = (context: TlaContext, formula: Expr, goalness: number): Node[] => {
332
+ const exprs = context.exprs;
333
+ const index = context.index;
334
+ const makeNode = (
335
+ name: "all_in" | "notex_in",
336
+ bounded: Expr,
337
+ membership: Expr,
338
+ set: Expr,
339
+ predicate: Expr,
340
+ term: Expr,
341
+ ): Node => {
342
+ const instance =
343
+ name === "all_in" ? exprs.apply(predicate, term) : exprs.enot(exprs.apply(predicate, term));
344
+ return {
345
+ conclusions: bounded === formula ? [membership, formula] : [formula, bounded],
346
+ rule: makeRule(name, [bounded, membership, instance, set, predicate]),
347
+ priority: { instance: formula },
348
+ goalness,
349
+ branches: [[instance]],
350
+ };
351
+ };
352
+ const getTermsIn = (set: Expr) =>
353
+ index
354
+ .findPositive("TLA.in")
355
+ .map((entry) => entry[0])
356
+ .filter(
357
+ (membership): membership is RelationExpr =>
358
+ isApp(membership, "TLA.in", 2) &&
359
+ membership.args[0].metas.length === 0 &&
360
+ membership.args[1] === set,
361
+ );
362
+ if (isApp(formula, "TLA.in", 2) && formula.args[0].metas.length === 0) {
363
+ const term = formula.args[0];
364
+ const set = formula.args[1];
365
+ const universals = index
366
+ .findPositive("TLA.bAll")
367
+ .map((entry) => entry[0])
368
+ .filter(
369
+ (bounded): bounded is RelationExpr =>
370
+ isApp(bounded, "TLA.bAll", 2) && bounded.args[0] === set,
371
+ );
372
+ const existentials = index
373
+ .findNegative("TLA.bEx")
374
+ .map((entry) => entry[0])
375
+ .filter(
376
+ (bounded): bounded is NegatedRelationExpr =>
377
+ bounded.kind === "not" &&
378
+ isApp(bounded.args[0], "TLA.bEx", 2) &&
379
+ bounded.args[0].args[0] === set,
380
+ );
381
+ const notExists = existentials.map((bounded) =>
382
+ makeNode("notex_in", bounded, formula, set, bounded.args[0].args[1], term),
383
+ );
384
+ const forAll = universals.map((bounded) =>
385
+ makeNode("all_in", bounded, formula, set, bounded.args[1], term),
386
+ );
387
+ return [...forAll.reverse(), ...notExists];
388
+ }
389
+ if (isApp(formula, "TLA.bAll", 2))
390
+ return getTermsIn(formula.args[0]).map((membership) =>
391
+ makeNode("all_in", formula, membership, formula.args[0], formula.args[1], membership.args[0]),
392
+ );
393
+ if (formula.kind === "not" && isApp(formula.args[0], "TLA.bEx", 2)) {
394
+ const bounded = formula.args[0];
395
+ return getTermsIn(bounded.args[0]).map((membership) =>
396
+ makeNode(
397
+ "notex_in",
398
+ formula,
399
+ membership,
400
+ bounded.args[0],
401
+ bounded.args[1],
402
+ membership.args[0],
403
+ ),
404
+ );
405
+ }
406
+ return [];
407
+ };
408
+
409
+ const makePropositionEqualityNode = (
410
+ exprs: Expressions,
411
+ name: "p_eq_l" | "p_eq_r" | "np_eq_l" | "np_eq_r",
412
+ formula: Expr,
413
+ left: Expr,
414
+ right: Expr,
415
+ goalness: number,
416
+ ): Node => {
417
+ const isNegated = name === "np_eq_l" || name === "np_eq_r";
418
+ const isLeft = name === "p_eq_l" || name === "np_eq_l";
419
+ const proposition = isNegated && formula.kind === "not" ? formula.args[0] : formula;
420
+ const equality = equal(exprs, left, right);
421
+ const differ = exprs.enot(equal(exprs, proposition, isLeft ? left : right));
422
+ const other = isLeft ? right : left;
423
+ const rest = isNegated ? exprs.enot(other) : other;
424
+ return {
425
+ conclusions: [formula, equality],
426
+ rule: makeRule(
427
+ name,
428
+ isNegated
429
+ ? [formula, equality, differ, rest, proposition, left, right]
430
+ : [formula, equality, differ, other, formula, left, right],
431
+ ),
432
+ priority: "arity_eq",
433
+ goalness,
434
+ branches: [[differ], [rest]],
435
+ };
436
+ };
437
+
438
+ const getPropositionEqualityNodes = (context: TlaContext, formula: Expr, goalness: number) => {
439
+ const exprs = context.exprs;
440
+ const index = context.index;
441
+ const atom = formula.kind === "not" ? formula.args[0] : formula;
442
+ if (atom.kind !== "app") return [];
443
+ const isNegated = formula.kind === "not";
444
+ const make = (isLeft: boolean) => (entry: [RelationExpr, number]) =>
445
+ makePropositionEqualityNode(
446
+ exprs,
447
+ isNegated ? (isLeft ? "np_eq_l" : "np_eq_r") : isLeft ? "p_eq_l" : "p_eq_r",
448
+ formula,
449
+ entry[0].args[0],
450
+ entry[0].args[1],
451
+ goalness,
452
+ );
453
+ return [
454
+ ...index.findTransLeft("=", atom.symbol).map(make(true)),
455
+ ...index.findTransRight("=", atom.symbol).map(make(false)),
456
+ ];
457
+ };
458
+
459
+ const getEqualityPropositionNodes = (
460
+ context: TlaContext,
461
+ formula: Expr,
462
+ isLeft: boolean,
463
+ ): Node[] => {
464
+ const exprs = context.exprs;
465
+ if (!isApp(formula, "=", 2)) return [];
466
+ const term = formula.args[isLeft ? 0 : 1];
467
+ if (term.kind !== "app") return [];
468
+ const index = context.index;
469
+ const make = (isNegated: boolean) => (entry: [Expr, number]) =>
470
+ makePropositionEqualityNode(
471
+ exprs,
472
+ isNegated ? (isLeft ? "np_eq_l" : "np_eq_r") : isLeft ? "p_eq_l" : "p_eq_r",
473
+ entry[0],
474
+ formula.args[0],
475
+ formula.args[1],
476
+ entry[1],
477
+ );
478
+ return [
479
+ ...index.findPositive(term.symbol).map(make(false)),
480
+ ...index.findNegative(term.symbol).map(make(true)),
481
+ ];
482
+ };
483
+
484
+ export interface ExtensionNodes {
485
+ nodes: Node[];
486
+ isStopped: boolean;
487
+ }
488
+
489
+ export const getExtensionNodes = (
490
+ context: TlaContext,
491
+ formula: Expr,
492
+ goalness: number,
493
+ ): ExtensionNodes => {
494
+ // OCaml evaluates the operands of @ right to left, so the last rules run first. The order
495
+ // decides the names of fresh variables.
496
+ const bounded = getBoundedInstances(context, formula, goalness);
497
+ const right = getEqualityPropositionNodes(context, formula, false);
498
+ const left = getEqualityPropositionNodes(context, formula, true);
499
+ const propositions = getPropositionEqualityNodes(context, formula, goalness);
500
+ const rewrites = getRewriteNodes(context, formula, goalness);
501
+ const props = getPropNodes(context, formula, goalness);
502
+ const items = [...props, ...rewrites, ...propositions, ...left, ...right, ...bounded];
503
+ const stop = items.indexOf("stop");
504
+ const kept = stop === -1 ? items : items.slice(0, stop);
505
+ return { nodes: kept.filter((item): item is Node => item !== "stop"), isStopped: stop !== -1 };
506
+ };
package/src/run-cli.ts CHANGED
@@ -8,7 +8,6 @@ import {
8
8
  writeFileSync,
9
9
  } from "node:fs";
10
10
  import { spawnSync } from "node:child_process";
11
- import { createHash } from "node:crypto";
12
11
  import { basename, delimiter, dirname, isAbsolute, join, resolve } from "node:path";
13
12
  import { arch, availableParallelism, release, tmpdir, type } from "node:os";
14
13
  import { pathToFileURL } from "node:url";
@@ -43,11 +42,12 @@ import {
43
42
  TlaUnsupportedError,
44
43
  } from "./errors";
45
44
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
46
- import type { LineRange } from "./obligation-generate";
47
- import { getAtPrefix, getLocusText } from "./obligation-expression";
45
+ import type { LineRange } from "./obligations/generate";
46
+ import { getAtPrefix, getLocusText } from "./obligations/expression";
48
47
  import { formatSummary, getObligations, WHOLE_MODULE, type ModuleObligations } from "./obligations";
49
48
  import { check } from "./parallel";
50
49
  import { parseModule } from "./parser";
50
+ import { isProveBackend, prove, PROVE_BACKENDS, type ProofStatus } from "./prove/prove";
51
51
  import type { StateDump } from "./state-graph";
52
52
  import {
53
53
  formatProbability,
@@ -55,10 +55,12 @@ import {
55
55
  getOptimisticProbability,
56
56
  getOutDegreeSummary,
57
57
  } from "./tlc-summary";
58
+ import { getTlapmPaths } from "./prove/tlapm/tlapm";
58
59
  import type { SanySpecification } from "./sany-generator";
59
60
  import { SANY_174_STANDARD_MODULES, SANY_STANDARD_MODULES } from "./sany-modules";
60
61
  import { getSanyModuleName, getSanyReport, type SanyModuleOrigin } from "./sany-report";
61
62
  import { exportSanyXml, XML_EXPORT_EXIT_CODE, type XmlExportOptions } from "./sany-xml";
63
+ import { getTlcFingerprint } from "./tlc-random";
62
64
  import { getTlcVersion, type TlcVersion } from "./tlc-version";
63
65
  import {
64
66
  createMessagePrinter,
@@ -111,6 +113,12 @@ const PROVE_COMMAND = defineCommand("tla-ts prove {options} <Module.tla|glob>...
111
113
  { flag: "-I <directory>", isRepeatable: true },
112
114
  ]);
113
115
 
116
+ const BACKEND_COMMAND = defineCommand("tla-ts prove {options} <Module.tla|glob>...", [
117
+ { flag: `--backend <${PROVE_BACKENDS.join("|")}>`, isRequired: true },
118
+ { flag: "-I <directory>", isRepeatable: true },
119
+ { flag: "-workers <count|auto>" },
120
+ ]);
121
+
114
122
  const XML_EXPORT_FLAGS = new Set(["-o", "-t", "-r", "-u"]);
115
123
 
116
124
  const XML_EXPORT_174_FLAGS = new Set(["-o"]);
@@ -166,6 +174,7 @@ const XML_EXPORT_USAGE = (() => {
166
174
  const USAGE = [
167
175
  `Usage: ${CHECK_COMMAND.usage}`,
168
176
  ` ${PROVE_COMMAND.usage}`,
177
+ ` ${BACKEND_COMMAND.usage}`,
169
178
  " tla-ts prove [<tlapm option>]... <Module.tla|glob>...",
170
179
  " tla-ts [<JVM option>]... tlc2.TLC <TLC option>... <Spec>",
171
180
  " (-cp tla2tools.jar or -Dtla-ts.tlc=1.7.4 picks the TLC to reproduce)",
@@ -705,9 +714,9 @@ const getStandardModulesUrl = (jar: string) =>
705
714
  `jar:file:${pathToFileURL(resolve(jar)).pathname}!/tla2sany/StandardModules/`;
706
715
 
707
716
  // Java's Files.createTempDirectory names a directory by a random unsigned long. tla-ts derives it
708
- // from what the directory holds, so that each run of a spec prints the same files.
709
- const getTemporaryName = (contents: string) =>
710
- createHash("sha256").update(contents).digest().readBigUInt64BE().toString();
717
+ // from TLC's fingerprint of what the directory holds, so that each run of a spec prints the same
718
+ // files.
719
+ const getTemporaryName = (contents: string) => getTlcFingerprint([contents]).toString();
711
720
 
712
721
  // The file TLC's SANY says it parses each module from: the real path of a module's own file, or a
713
722
  // copy in a temporary directory of a module from the root module's file or from the jar on the
@@ -1043,12 +1052,6 @@ const runEach = async (
1043
1052
 
1044
1053
  // tlapm installs its standard library, with modules such as TLAPS, at lib/tlapm/stdlib beside
1045
1054
  // bin/tlapm.
1046
- const getTlapmPaths = () =>
1047
- (process.env.PATH ?? "")
1048
- .split(delimiter)
1049
- .map((directory) => join(directory, "tlapm"))
1050
- .filter((path) => existsSync(path));
1051
-
1052
1055
  const getTlapmLibrary = () =>
1053
1056
  getTlapmPaths()
1054
1057
  .map((path) => join(dirname(dirname(realpathSync(path))), "lib/tlapm/stdlib"))
@@ -1123,7 +1126,57 @@ const generateObligations = (generate: () => ModuleObligations[]) => {
1123
1126
  }
1124
1127
  };
1125
1128
 
1126
- const prove = (args: string[]) => {
1129
+ // tla-ts prove --backend: proves each module with prove, printing each obligation as it ends.
1130
+ const proveWithBackend = (args: string[]) => {
1131
+ const parsed = BACKEND_COMMAND.parse(args);
1132
+ const backend = parsed.get("--backend")?.[0];
1133
+ if (parsed.unknown[0] !== undefined || parsed.incomplete || !isProveBackend(backend)) {
1134
+ console.error(`Usage: ${BACKEND_COMMAND.usage}`);
1135
+ return 1;
1136
+ }
1137
+ const modulePaths = expandGlobs(parsed.positionals).map((path) =>
1138
+ path.endsWith(".tla") ? path : `${path}.tla`,
1139
+ );
1140
+ if (modulePaths.length === 0) {
1141
+ console.error(`Usage: ${BACKEND_COMMAND.usage}`);
1142
+ return 1;
1143
+ }
1144
+ const tlapmLibrary = getTlapmLibrary();
1145
+ const includes = parsed.options.flatMap((option) => (option.name === "-I" ? option.values : []));
1146
+ return runEach(
1147
+ modulePaths,
1148
+ async (path) => {
1149
+ const directories = [
1150
+ dirname(path),
1151
+ ".",
1152
+ ...(tlapmLibrary ? [tlapmLibrary] : []),
1153
+ ...includes.toReversed(),
1154
+ ];
1155
+ const result = await prove({
1156
+ source: readFileSync(path, "utf8"),
1157
+ loadModule: (name) =>
1158
+ directories.map((directory) => readModule(`${directory}/${name}.tla`)).find(Boolean)
1159
+ ?.source,
1160
+ backend,
1161
+ workers: getWorkerCount(parsed.get("-workers")),
1162
+ onObligation: (obligation) =>
1163
+ console.log(
1164
+ `${path}:${obligation.location}: ${obligation.status}${obligation.status === "proved" ? ` by ${obligation.prover}` : ""}${obligation.status === "failed" || obligation.status === "unsupported" ? ` (${obligation.reason})` : ""}`,
1165
+ ),
1166
+ });
1167
+ const counts = Map.groupBy(result.obligations, (obligation) => obligation.status);
1168
+ const getCount = (status: ProofStatus) => counts.get(status)?.length ?? 0;
1169
+ console.log(
1170
+ `${result.obligations.length} obligations: ${getCount("proved")} proved, ${getCount("trivial")} trivial, ${getCount("failed")} failed, ${getCount("unsupported")} unsupported`,
1171
+ );
1172
+ return getCount("failed") + getCount("unsupported") === 0 ? EXIT_STATUS.success : 1;
1173
+ },
1174
+ () => createMessagePrinter(false),
1175
+ );
1176
+ };
1177
+
1178
+ const runProve = (args: string[]) => {
1179
+ if (args.includes("--backend")) return proveWithBackend(args);
1127
1180
  if (!args.includes("-N") && !args.includes("--summary")) return proveWithTlapm(args);
1128
1181
  const parsed = PROVE_COMMAND.parse(args);
1129
1182
  const unsupported = parsed.unknown[0];
@@ -1247,7 +1300,7 @@ const checkSpecs = async (args: string[], java: JavaProperties) => {
1247
1300
  ? path
1248
1301
  : (java.libraries.map((directory) => join(directory, path)).find(existsSync) ?? path);
1249
1302
  const paths = [...new Set(specPaths.map(findSpec))];
1250
- const tlcVersion = getJavaTlcVersion(java);
1303
+ const tlcVersion = java.tlcVersion ?? "master";
1251
1304
  return runEach(
1252
1305
  paths,
1253
1306
  (path, printer) => {
@@ -1488,9 +1541,6 @@ interface JavaProperties {
1488
1541
  const getJar = (java: JavaProperties) =>
1489
1542
  java.classPath?.split(delimiter).find((entry) => entry.endsWith(".jar"));
1490
1543
 
1491
- // The TLC that -Dtla-ts.tlc names, or else the one of the jar on the class path.
1492
- const getJavaTlcVersion = (java: JavaProperties) => java.tlcVersion ?? getTlcVersion(getJar(java));
1493
-
1494
1544
  interface JavaLaunch {
1495
1545
  mainClass: string;
1496
1546
  args: string[];
@@ -1525,7 +1575,7 @@ const runJavaClass = (launch: JavaLaunch) => {
1525
1575
  if (launch.mainClass === "tlc2.TLC") return checkSpecs(launch.args, launch.java);
1526
1576
  if (launch.mainClass === "tla2sany.xml.XMLExporter") {
1527
1577
  return reportErrors(() =>
1528
- getJavaTlcVersion(launch.java) === "1.7.4"
1578
+ launch.java.tlcVersion === "1.7.4"
1529
1579
  ? exportXml174(launch.args, getJar(launch.java))
1530
1580
  : exportXml(launch.args),
1531
1581
  );
@@ -1537,9 +1587,12 @@ const runJavaClass = (launch: JavaLaunch) => {
1537
1587
  };
1538
1588
 
1539
1589
  const run = async (args: string[]) => {
1540
- if (args[0] === "prove") return reportErrors(() => prove(args.slice(1)));
1590
+ if (args[0] === "prove") return reportErrors(() => runProve(args.slice(1)));
1541
1591
  const launch = getJavaLaunch(args);
1542
- return launch ? runJavaClass(launch) : checkSpecs(args, { libraries: [] });
1592
+ if (launch === undefined) return checkSpecs(args, { libraries: [] });
1593
+ // The TLC that -Dtla-ts.tlc names, or else the one of the jar on the class path.
1594
+ launch.java.tlcVersion ??= await getTlcVersion(getJar(launch.java));
1595
+ return runJavaClass(launch);
1543
1596
  };
1544
1597
 
1545
1598
  export const runCli = async () => {