tla-ts 0.0.4-dev.6dec595 → 0.0.4-dev.7b5087a

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 (307) hide show
  1. package/README.md +27 -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 +996 -0
  15. package/dist/prove.js +996 -0
  16. package/dist/run-cli.cjs +517 -47
  17. package/dist/run-cli.js +517 -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/errors.ts +86 -0
  26. package/src/evaluate.ts +28 -7
  27. package/src/index.ts +10 -0
  28. package/src/{obligation-action.ts → obligations/action.ts} +258 -37
  29. package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
  30. package/src/obligations/ctx.ts +64 -0
  31. package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
  32. package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
  33. package/src/{obligation-format.ts → obligations/format.ts} +6 -5
  34. package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
  35. package/src/{obligations.ts → obligations/index.ts} +28 -12
  36. package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
  37. package/src/{obligation-module.ts → obligations/module.ts} +46 -20
  38. package/src/obligations/pickle.ts +100 -0
  39. package/src/obligations/pragma.ts +189 -0
  40. package/src/{obligation-printer.ts → obligations/printer.ts} +9 -63
  41. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  42. package/src/{obligation-source.ts → obligations/source.ts} +91 -35
  43. package/src/obligations/temporal.ts +319 -0
  44. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  45. package/src/ocaml-marshal.ts +172 -0
  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 +33 -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 +512 -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 +33 -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 +27 -0
  115. package/src/prove/prove.ts +528 -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 +97 -0
  261. package/src/prove/tlaps-module.ts +510 -0
  262. package/src/prove/verdict.ts +19 -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 +338 -52
  303. package/src/tlapm-cache.ts +250 -0
  304. package/src/values.ts +8 -3
  305. package/src/worker.ts +65 -0
  306. package/dist/parallel.cjs +0 -12
  307. package/dist/parallel.js +0 -12
@@ -0,0 +1,528 @@
1
+ // Proves a module's obligations with tla-ts's own backends, in tlapm's order, or with tlapm.
2
+
3
+ import { TlaProverError, TlaUnsupportedError } from "../errors";
4
+ import { getChildren, mapHyp, type Expr, type Hyp, type Sequent } from "../obligations/expression";
5
+ import { getObligations, type PrintedObligation } from "../obligations";
6
+ import { formatObligation } from "../obligations/printer";
7
+ import { isWorkerSupported } from "../worker";
8
+ import { decide } from "./deciders";
9
+ import { createDecidePool } from "./decide-pool";
10
+ import { encodeIsabelle, encodeIsabelleTheory } from "./isabelle/encode";
11
+ import { processObligation } from "./prep/action";
12
+ import { expandDefs } from "./prep/defs";
13
+ import { normalizeSequent } from "./prep/elab";
14
+ import { expandEnabledCdot } from "./prep/enabled";
15
+ import { getFingerprint } from "./prep/fingerprint";
16
+ import { flatten } from "./prep/flatten";
17
+ import { findMethods, type Method } from "./prep/pragma";
18
+ import { isTrivial } from "./prep/trivial";
19
+ import { encodePtl } from "./ptl/encode";
20
+ import { encodeSmt } from "./smt/encode";
21
+ import type { EncodingSession } from "./smt/rewrite";
22
+ import { encodeZenon } from "./zenon/encode";
23
+ import type { TlapmResult } from "./tlapm/tlapm";
24
+ import { TLAPS_MODULE } from "./tlaps-module";
25
+ import type { DecideOptions, Decision, Verdict } from "./verdict";
26
+
27
+ interface ObligationBase {
28
+ id: number;
29
+ location: string;
30
+ text: string;
31
+ }
32
+
33
+ export interface ProvedObligation extends ObligationBase {
34
+ status: "proved";
35
+ prover: string;
36
+ }
37
+
38
+ export interface TrivialObligation extends ObligationBase {
39
+ status: "trivial";
40
+ }
41
+
42
+ export interface UnprovedObligation extends ObligationBase {
43
+ status: "failed" | "unsupported";
44
+ reason: string;
45
+ }
46
+
47
+ export type ProofObligation = ProvedObligation | TrivialObligation | UnprovedObligation;
48
+
49
+ export type ProofStatus = ProofObligation["status"];
50
+
51
+ export interface ProveResult {
52
+ obligations: ProofObligation[];
53
+ missingProofCount: number;
54
+ omittedProofCount: number;
55
+ }
56
+
57
+ // tla-ts runs its own backends, and tlapm runs tlapm on the module.
58
+ export const PROVE_BACKENDS = ["tla-ts", "tlapm"] as const;
59
+
60
+ export type ProveBackend = (typeof PROVE_BACKENDS)[number];
61
+
62
+ export const isProveBackend = (name: string | undefined): name is ProveBackend =>
63
+ PROVE_BACKENDS.some((backend) => backend === name);
64
+
65
+ export interface ProveOptions {
66
+ source: string;
67
+ loadModule?: (name: string) => string | undefined;
68
+ backend?: ProveBackend;
69
+ signal?: AbortSignal;
70
+ onObligation?: (obligation: ProofObligation) => void;
71
+ workers?: number;
72
+ }
73
+
74
+ // What one method concluded about an obligation, as tlapm's toolbox messages report it. tlapm's
75
+ // reason for a failure is false when the backend answered, timeout when it ran out of time, or why
76
+ // tla-ts couldn't run it. A result reused from an earlier obligation with the same fingerprint, as
77
+ // Fpfile keeps it, has no time used.
78
+ export interface ProofAttempt {
79
+ method: Method;
80
+ isProved: boolean;
81
+ isReused: boolean;
82
+ reason?: string;
83
+ verdict?: Verdict;
84
+ timeUsedMs?: number;
85
+ }
86
+
87
+ export interface ProofReport {
88
+ obligation: ProofObligation;
89
+ attempts: ProofAttempt[];
90
+ }
91
+
92
+ // An obligation being proved. The SMT encoder numbers the CASE errors it standardizes across the
93
+ // run, so an obligation it encodes one in waits for every earlier obligation and keeps a session
94
+ // from the count they leave.
95
+ interface ObligationTask {
96
+ done: Promise<void>;
97
+ session: { initial: number; current: EncodingSession } | undefined;
98
+ }
99
+
100
+ // What tlapm keeps across the obligations of one run: the SMT encoder's counter, and what each
101
+ // prover concluded for each fingerprint. An obligation waits for the last earlier one with its
102
+ // fingerprint, so obligations prove concurrently as they would in turn. Fpfile keeps one Isabelle
103
+ // result, which only a method with the same tactic reuses.
104
+ interface ProveRun {
105
+ tasks: ObligationTask[];
106
+ results: Map<string, Map<string, ProofAttempt>>;
107
+ isFingerprinted: (obligation: PrintedObligation) => boolean;
108
+ isProving: boolean;
109
+ lastByFingerprint: Map<string, Promise<void>>;
110
+ decide: (
111
+ prover: string,
112
+ text: string,
113
+ options: DecideOptions,
114
+ priority: number,
115
+ ) => Promise<Decision>;
116
+ }
117
+
118
+ interface Backend {
119
+ // The text tlapm sends the backend for an obligation after Prep.normalize_expand, through the
120
+ // frontend and Prep.flatten that Prep.ship applies first. It throws a TlaUnsupportedError for
121
+ // what tla-ts can't encode.
122
+ encode: (id: number, sequent: Sequent, method: Method, session: EncodingSession) => string;
123
+ }
124
+
125
+ // Action.process_obligation, the frontend for every backend but LS4, Isabelle included, then
126
+ // Prep.flatten.
127
+ const shipFirstOrder = (sequent: Sequent) => flatten(processObligation(sequent));
128
+
129
+ const SMT: Backend = {
130
+ // Prep.gen_smt_solve writes the resource budget before the encoding.
131
+ encode: (_id, sequent, method, session) =>
132
+ (method.rlimit === undefined ? "" : `(set-option :rlimit ${method.rlimit})\n`) +
133
+ encodeSmt(shipFirstOrder(sequent), session),
134
+ };
135
+
136
+ // tla-ts's backends, by the prover of the method that selects each.
137
+ const BACKENDS: Record<string, Backend> = {
138
+ smt: SMT,
139
+ z3: SMT,
140
+ zenon: { encode: (id, sequent) => encodeZenon(id, shipFirstOrder(sequent)) },
141
+ // tlapm names the theory after its temporary file, and tla-ts after the obligation.
142
+ isabelle: {
143
+ encode: (id, sequent, method) =>
144
+ encodeIsabelle(id, shipFirstOrder(sequent), method.tactic ?? "auto", `tlapm_${id}`),
145
+ },
146
+ // Pltl.process_obligation is LS4's frontend.
147
+ ls4: { encode: (_id, sequent) => encodePtl(sequent) },
148
+ };
149
+
150
+ // Whether an expression has a CASE with no OTHER. The frontends and Prep.flatten add none, so the
151
+ // SMT encoder standardizes one only in an obligation that has one after Prep.normalize_expand.
152
+ const hasIncompleteCase = (expression: Expr): boolean =>
153
+ (expression.kind === "Case" && expression.other === undefined) ||
154
+ getChildren(expression).some(hasIncompleteCase);
155
+
156
+ const incompleteCaseHyps = new WeakMap<Hyp, boolean>();
157
+
158
+ const isIncompleteCaseHyp = (hyp: Hyp) => {
159
+ const known = incompleteCaseHyps.get(hyp);
160
+ if (known !== undefined) return known;
161
+ const expressions: Expr[] = [];
162
+ mapHyp(
163
+ hyp,
164
+ (inner) => {
165
+ expressions.push(inner);
166
+ return inner;
167
+ },
168
+ "all",
169
+ );
170
+ const isIncomplete = expressions.some(hasIncompleteCase);
171
+ incompleteCaseHyps.set(hyp, isIncomplete);
172
+ return isIncomplete;
173
+ };
174
+
175
+ const getModuleName = (source: string) => /-{4,}\s*MODULE\s+(\w+)/.exec(source)?.[1] ?? "Main";
176
+
177
+ const getBase = (obligation: PrintedObligation): ObligationBase => ({
178
+ id: obligation.id,
179
+ location: obligation.location,
180
+ text: obligation.text,
181
+ });
182
+
183
+ const getUnproved = (
184
+ obligation: PrintedObligation,
185
+ status: "failed" | "unsupported",
186
+ reason: string,
187
+ ): ProofObligation => ({ ...getBase(obligation), status, reason });
188
+
189
+ // Prep.normalize_expand: expand_defs, Elab.normalize, then the frontends the step cites.
190
+ const normalizeExpand = (sequent: Sequent, frontends: Set<string>) =>
191
+ expandEnabledCdot(normalizeSequent(expandDefs(sequent)), frontends);
192
+
193
+ // The obligation as tlapm prints it in a toolbox message about a failure: Prep.normalize_expand
194
+ // for a new one, and Toolbox.normalize, which keeps pragmas, for one it reused.
195
+ export const formatNormalized = (obligation: PrintedObligation, isReused: boolean) =>
196
+ `${formatObligation(isReused ? normalizeSequent(expandDefs(obligation.sequent, false)) : normalizeExpand(obligation.sequent, findMethods(obligation).frontends))}\n`;
197
+
198
+ // The theory tlapm writes of the proofs Isabelle found for a module's obligations, in the order
199
+ // it found them. tlapm also writes there each proof Zenon found, which tla-ts leaves out.
200
+ export const encodeProofTheory = (
201
+ name: string,
202
+ reports: ProofReport[],
203
+ obligations: PrintedObligation[],
204
+ ) =>
205
+ encodeIsabelleTheory(
206
+ name,
207
+ reports.flatMap((report, index) =>
208
+ report.attempts
209
+ .filter(
210
+ (attempt) =>
211
+ attempt.method.prover === "isabelle" && attempt.isProved && !attempt.isReused,
212
+ )
213
+ .map((attempt) => ({
214
+ id: report.obligation.id,
215
+ sequent: shipFirstOrder(
216
+ normalizeExpand(obligations[index].sequent, findMethods(obligations[index]).frontends),
217
+ ),
218
+ tactic: attempt.method.tactic ?? "auto",
219
+ })),
220
+ ),
221
+ );
222
+
223
+ // The text one backend receives for an obligation, for comparing with tlapm's.
224
+ export const encodeForBackend = (
225
+ obligation: PrintedObligation,
226
+ prover: string,
227
+ session: EncodingSession,
228
+ ) => {
229
+ const backend = BACKENDS[prover];
230
+ if (!backend) throw new TlaUnsupportedError(`the ${prover} backend`);
231
+ const methods = findMethods(obligation);
232
+ const method = methods.provers.find((candidate) => candidate.prover === prover) ?? {
233
+ prover,
234
+ timeLimitMs: Infinity,
235
+ };
236
+ return backend.encode(
237
+ obligation.id,
238
+ normalizeExpand(obligation.sequent, methods.frontends),
239
+ method,
240
+ session,
241
+ );
242
+ };
243
+
244
+ // The SMT encoder's session for an obligation, from the count of CASE errors every earlier
245
+ // obligation leaves.
246
+ const getSession = async (run: ProveRun, index: number) => {
247
+ const task = run.tasks[index];
248
+ if (task.session) return task.session.current;
249
+ const earlier = run.tasks.slice(0, index);
250
+ await Promise.all(earlier.map((innerTask) => innerTask.done));
251
+ const initial = earlier.reduce(
252
+ (total, innerTask) =>
253
+ total +
254
+ (innerTask.session ? innerTask.session.current.caseErrors - innerTask.session.initial : 0),
255
+ 0,
256
+ );
257
+ task.session = { initial, current: { caseErrors: initial } };
258
+ return task.session.current;
259
+ };
260
+
261
+ // Prep.ship: the provers the step cites, or tlapm's default ones when it cites none, each tried in
262
+ // turn until one proves the obligation. Prep.already_processed reuses what a prover concluded for
263
+ // an earlier obligation with the same fingerprint: a proof, or a failure within at least as much
264
+ // time. Unless the first prover's proof is reused, a trivial obligation needs no prover.
265
+ const proveWithBackends = async (
266
+ obligation: PrintedObligation,
267
+ index: number,
268
+ run: ProveRun,
269
+ signal: AbortSignal | undefined,
270
+ ): Promise<ProofReport> => {
271
+ if (obligation.kind.kind === "Error")
272
+ return { obligation: getUnproved(obligation, "failed", obligation.kind.message), attempts: [] };
273
+ const methods = findMethods(obligation);
274
+ const fingerprint = getFingerprint(obligation.sequent);
275
+ const earlier = run.lastByFingerprint.get(fingerprint);
276
+ run.lastByFingerprint.set(fingerprint, run.tasks[index].done);
277
+ await earlier;
278
+ const attempts: ProofAttempt[] = [];
279
+ const getProved = (prover: string): ProofReport => ({
280
+ obligation: { ...getBase(obligation), status: "proved", prover },
281
+ attempts,
282
+ });
283
+ // Prep.already_processed: --nofp forgets the fingerprint's results before each method.
284
+ const getPrior = (method: Method) => {
285
+ if (!run.isFingerprinted(obligation)) run.results.delete(fingerprint);
286
+ const prior = run.results.get(fingerprint)?.get(method.prover);
287
+ return prior?.method.tactic === method.tactic ? prior : undefined;
288
+ };
289
+ // Fpfile.get_timeout: a method with an rlimit stores it in place of its time limit.
290
+ const getBudget = (method: Method) => method.rlimit ?? method.timeLimitMs / 1000;
291
+ const reuse = (prior: ProofAttempt) =>
292
+ attempts.push({ ...prior, isReused: true, timeUsedMs: undefined });
293
+ const firstPrior = getPrior(methods.provers[0]);
294
+ if (firstPrior?.isProved) {
295
+ reuse(firstPrior);
296
+ return getProved(firstPrior.method.prover);
297
+ }
298
+ const sequent = normalizeExpand(obligation.sequent, methods.frontends);
299
+ // Fpfile.fp_writes keeps no trivial result, but adds the fingerprint.
300
+ if (obligation.kind.kind === "Support" && isTrivial(sequent)) {
301
+ run.results.set(fingerprint, run.results.get(fingerprint) ?? new Map());
302
+ return { obligation: { ...getBase(obligation), status: "trivial" }, attempts };
303
+ }
304
+ const reasons: string[] = [];
305
+ const state = { isDecided: false };
306
+ const decideAttempt = (attempt: ProofAttempt) => {
307
+ attempts.push(attempt);
308
+ run.results.set(
309
+ fingerprint,
310
+ (run.results.get(fingerprint) ?? new Map()).set(attempt.method.prover, attempt),
311
+ );
312
+ state.isDecided = true;
313
+ };
314
+ for (const method of methods.provers) {
315
+ const prior = getPrior(method);
316
+ if (prior?.isProved) {
317
+ reuse(prior);
318
+ return getProved(method.prover);
319
+ }
320
+ if (prior && getBudget(prior.method) >= getBudget(method)) {
321
+ reuse(prior);
322
+ state.isDecided = true;
323
+ reasons.push(`${method.prover} failed on an obligation with the same fingerprint`);
324
+ continue;
325
+ }
326
+ // Prep.really_ship: --noproving sends nothing to a backend.
327
+ if (!run.isProving) continue;
328
+ // Prep.prove_with: the Trivial method proves anything.
329
+ if (method.prover === "trivial") return getProved(method.prover);
330
+ const backend = BACKENDS[method.prover];
331
+ if (!backend) {
332
+ const reason = `tla-ts has no ${method.prover} backend`;
333
+ attempts.push({ method, isProved: false, isReused: false, reason });
334
+ reasons.push(reason);
335
+ continue;
336
+ }
337
+ try {
338
+ const isCaseNumbered =
339
+ backend === SMT &&
340
+ (sequent.context.some(isIncompleteCaseHyp) || hasIncompleteCase(sequent.active));
341
+ const session = isCaseNumbered ? await getSession(run, index) : { caseErrors: 0 };
342
+ const text = backend.encode(obligation.id, sequent, method, session);
343
+ const decision = await run.decide(
344
+ method.prover,
345
+ text,
346
+ { timeLimitMs: method.timeLimitMs, signal },
347
+ index,
348
+ );
349
+ const isProved = decision.verdict === "unsat";
350
+ decideAttempt({
351
+ method,
352
+ isProved,
353
+ isReused: false,
354
+ ...(!isProved && {
355
+ reason: decision.timeUsedMs >= method.timeLimitMs ? "timeout" : "false",
356
+ }),
357
+ verdict: decision.verdict,
358
+ timeUsedMs: decision.timeUsedMs,
359
+ });
360
+ if (isProved) return getProved(method.prover);
361
+ reasons.push(`${method.prover} answered ${decision.verdict}`);
362
+ } catch (error) {
363
+ if (error instanceof TlaProverError) {
364
+ decideAttempt({ method, isProved: false, isReused: false, reason: "false" });
365
+ reasons.push(`${method.prover} failed: ${error.message}`);
366
+ continue;
367
+ }
368
+ if (!(error instanceof TlaUnsupportedError)) throw error;
369
+ const reason = `${method.prover} can't encode ${error.message}`;
370
+ attempts.push({ method, isProved: false, isReused: false, reason });
371
+ reasons.push(reason);
372
+ }
373
+ }
374
+ return {
375
+ obligation: getUnproved(
376
+ obligation,
377
+ state.isDecided ? "failed" : "unsupported",
378
+ reasons.join(", "),
379
+ ),
380
+ attempts,
381
+ };
382
+ };
383
+
384
+ // The one place an error becomes a result: what tla-ts can't handle is unsupported, and what tlapm
385
+ // refuses, as a frontend's soundness check, fails.
386
+ const getResult = async (
387
+ obligation: PrintedObligation,
388
+ getReport: () => Promise<ProofReport>,
389
+ ): Promise<ProofReport> => {
390
+ try {
391
+ return await getReport();
392
+ } catch (error) {
393
+ if (error instanceof TlaUnsupportedError)
394
+ return { obligation: getUnproved(obligation, "unsupported", error.message), attempts: [] };
395
+ if (error instanceof TlaProverError)
396
+ return { obligation: getUnproved(obligation, "failed", error.message), attempts: [] };
397
+ throw error;
398
+ }
399
+ };
400
+
401
+ interface ObligationsOptions {
402
+ workers?: number;
403
+ signal?: AbortSignal;
404
+ onReport?: (report: ProofReport, obligation: PrintedObligation) => void;
405
+ // What each prover concluded for each fingerprint, which tla-ts tlapm loads from tlapm's
406
+ // fingerprints file and saves back, as the run updates it.
407
+ results?: Map<string, Map<string, ProofAttempt>>;
408
+ // tlapm's --nofp and --nofpl: whether to reuse what was concluded for an obligation.
409
+ isFingerprinted?: (obligation: PrintedObligation) => boolean;
410
+ // tlapm's --noproving: reuse what was concluded, and run no backend.
411
+ isProving?: boolean;
412
+ }
413
+
414
+ // Proves obligations generated elsewhere, as tla-ts tlapm generates them like tlapm, reporting each
415
+ // with what each method concluded.
416
+ export const proveObligations = async (
417
+ obligations: PrintedObligation[],
418
+ options: ObligationsOptions,
419
+ ) => {
420
+ const count = options.workers ?? 1;
421
+ const pool = count > 1 && isWorkerSupported() ? await createDecidePool(count) : undefined;
422
+ const onAbort = () => pool?.terminate(options.signal?.reason);
423
+ options.signal?.addEventListener("abort", onAbort);
424
+ const run: ProveRun = {
425
+ tasks: [],
426
+ results: options.results ?? new Map(),
427
+ isFingerprinted: options.isFingerprinted ?? (() => true),
428
+ isProving: options.isProving ?? true,
429
+ lastByFingerprint: new Map(),
430
+ decide:
431
+ pool?.decide ?? (async (prover, text, decideOptions) => decide(prover, text, decideOptions)),
432
+ };
433
+ // A few obligations per worker prove at once, and each reports once every earlier one has.
434
+ const limit = pool ? count * 4 : 1;
435
+ const pending: Promise<ProofReport>[] = [];
436
+ const isSettled: boolean[] = [];
437
+ const running = new Set<Promise<void>>();
438
+ const reports: ProofReport[] = [];
439
+ const reportSettled = async () => {
440
+ while (isSettled[reports.length]) {
441
+ options.signal?.throwIfAborted();
442
+ const report = await pending[reports.length];
443
+ reports.push(report);
444
+ options.onReport?.(report, obligations[reports.length - 1]);
445
+ // HACK: backends on this thread run synchronously, so yield to let an abort land.
446
+ await new Promise((resolve) => setTimeout(resolve));
447
+ }
448
+ };
449
+ try {
450
+ for (const [index, obligation] of obligations.entries()) {
451
+ options.signal?.throwIfAborted();
452
+ const done = Promise.withResolvers<void>();
453
+ run.tasks.push({ done: done.promise, session: undefined });
454
+ const report = getResult(obligation, () =>
455
+ proveWithBackends(obligation, index, run, options.signal),
456
+ );
457
+ pending.push(report);
458
+ running.add(done.promise);
459
+ const settle = () => {
460
+ isSettled[index] = true;
461
+ running.delete(done.promise);
462
+ done.resolve();
463
+ };
464
+ void report.then(settle, settle);
465
+ if (running.size >= limit) await Promise.race(running);
466
+ await reportSettled();
467
+ }
468
+ await Promise.all(running);
469
+ await reportSettled();
470
+ } finally {
471
+ options.signal?.removeEventListener("abort", onAbort);
472
+ pool?.terminate(new TlaProverError("prove stopped"));
473
+ }
474
+ return reports;
475
+ };
476
+
477
+ const getFromTlapm = (obligation: PrintedObligation, result: TlapmResult | undefined) =>
478
+ result
479
+ ? { ...getBase(obligation), ...result }
480
+ : getUnproved(obligation, "unsupported", "tlapm reported no result");
481
+
482
+ export const prove = async (options: ProveOptions): Promise<ProveResult> => {
483
+ const name = getModuleName(options.source);
484
+ const modules = new Map<string, string>();
485
+ const results = getObligations(
486
+ [{ file: `${name}.tla`, source: options.source }],
487
+ (moduleName) => {
488
+ const source = options.loadModule?.(moduleName);
489
+ if (source !== undefined) modules.set(moduleName, source);
490
+ const loaded = source ?? (moduleName === "TLAPS" ? TLAPS_MODULE : undefined);
491
+ return loaded === undefined ? undefined : { file: `${moduleName}.tla`, source: loaded };
492
+ },
493
+ );
494
+ const obligations = results.flatMap((result) => result.obligations);
495
+ const counts = {
496
+ missingProofCount: results.reduce((total, result) => total + result.summary.absent.length, 0),
497
+ omittedProofCount: results.reduce((total, result) => total + result.summary.omitted.length, 0),
498
+ };
499
+ if (options.backend === "tlapm") {
500
+ if (typeof process === "undefined" || process.versions?.node === undefined)
501
+ throw new TlaUnsupportedError("The tlapm backend runs only in Node and Bun.");
502
+ const tlapm = await import("./tlapm/tlapm");
503
+ const byId = new Map(obligations.map((obligation) => [obligation.id, obligation]));
504
+ const reported = await tlapm.proveWithTlapm(
505
+ name,
506
+ new Map([[name, options.source], ...modules]),
507
+ {
508
+ signal: options.signal,
509
+ onResult: (id, result) => {
510
+ const obligation = byId.get(id);
511
+ if (obligation) options.onObligation?.(getFromTlapm(obligation, result));
512
+ },
513
+ },
514
+ );
515
+ return {
516
+ obligations: obligations.map((obligation) =>
517
+ getFromTlapm(obligation, reported.get(obligation.id)),
518
+ ),
519
+ ...counts,
520
+ };
521
+ }
522
+ const reports = await proveObligations(obligations, {
523
+ workers: options.workers,
524
+ signal: options.signal,
525
+ onReport: (report) => options.onObligation?.(report.obligation),
526
+ });
527
+ return { obligations: reports.map((report) => report.obligation), ...counts };
528
+ };
@@ -0,0 +1,68 @@
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
+ import { TlaSyntaxError } from "../../errors";
5
+ import type { DecideOptions, Verdict } from "../verdict";
6
+ import { getSatisfiability, type PtlFormula } from "./tableau";
7
+
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
+ const parseLs4 = (text: string): PtlFormula => {
11
+ const tokens = text.match(/<->|->|[()~&|]|[\w']+|\S/g) ?? [];
12
+ const state = { position: 0 };
13
+ const take = (expected?: string) => {
14
+ const token = tokens[state.position++];
15
+ if (token === undefined || (expected !== undefined && token !== expected))
16
+ throw new TlaSyntaxError(
17
+ `Expected ${expected ?? "a formula"} in LS4 input, found ${token ?? "the end"}`,
18
+ );
19
+ return token;
20
+ };
21
+ const parseUnary = (): PtlFormula => {
22
+ const token = take();
23
+ if (token === "(") {
24
+ const inner = parseEquiv();
25
+ take(")");
26
+ return inner;
27
+ }
28
+ if (token === "~" || token === "not") return { kind: "Not", body: parseUnary() };
29
+ if (token === "always") return { kind: "Always", body: parseUnary() };
30
+ if (token === "sometime") return { kind: "Eventually", body: parseUnary() };
31
+ if (token === "next") return { kind: "Next", body: parseUnary() };
32
+ if (!/^[\w']+$/.test(token))
33
+ throw new TlaSyntaxError(`Expected a formula in LS4 input, found ${token}`);
34
+ return { kind: "Atom", name: token };
35
+ };
36
+ const parseJunction = (operator: string, kind: "And" | "Or", parseOperand: () => PtlFormula) => {
37
+ const operands = [parseOperand()];
38
+ while (tokens[state.position] === operator) {
39
+ take();
40
+ operands.push(parseOperand());
41
+ }
42
+ return operands.reduce((left, right) => ({ kind, left, right }));
43
+ };
44
+ const parseImplies = (): PtlFormula => {
45
+ const left = parseJunction("|", "Or", () => parseJunction("&", "And", parseUnary));
46
+ if (tokens[state.position] !== "->") return left;
47
+ take();
48
+ return { kind: "Implies", left, right: parseImplies() };
49
+ };
50
+ const parseEquiv = (): PtlFormula => {
51
+ const left = parseImplies();
52
+ if (tokens[state.position] !== "<->") return left;
53
+ take();
54
+ return { kind: "Equiv", left, right: parseEquiv() };
55
+ };
56
+ const formula = parseEquiv();
57
+ if (state.position < tokens.length)
58
+ throw new TlaSyntaxError(`Expected the end of LS4 input, found ${tokens[state.position]}`);
59
+ return formula;
60
+ };
61
+
62
+ export const decidePtl = (text: string, options: DecideOptions): Verdict => {
63
+ const deadline = performance.now() + options.timeLimitMs;
64
+ return getSatisfiability(
65
+ parseLs4(text),
66
+ () => options.signal?.aborted === true || performance.now() > deadline,
67
+ );
68
+ };