tla-ts 0.0.8-dev.d9bffda → 0.0.9-dev.0493be549

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (390) hide show
  1. package/README.md +30 -0
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +28 -28
  5. package/dist/deciders.js +43 -43
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +80 -10
  8. package/dist/index.d.ts +80 -10
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +116 -36
  15. package/dist/prove.js +116 -36
  16. package/dist/run.cjs +143 -31
  17. package/dist/run.js +143 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +128 -103
  21. package/dist/transfer.js +128 -103
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +3 -1
  25. package/src/ast.ts +7 -21
  26. package/src/bags.ts +99 -99
  27. package/src/builtins.ts +44 -75
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check.ts +605 -311
  30. package/src/cli/options.ts +12 -6
  31. package/src/cli/run.ts +2 -2
  32. package/src/cli/runtime-invariants.ts +135 -0
  33. package/src/cli/shared.ts +20 -9
  34. package/src/cli/tlapm.ts +0 -12
  35. package/src/cli/tlc-arguments.ts +646 -0
  36. package/src/cli/tlc-usage.ts +362 -0
  37. package/src/cli/tlc.ts +545 -218
  38. package/src/cli/typescript.ts +23 -0
  39. package/src/cli/xml-exporter.ts +4 -16
  40. package/src/cli.ts +0 -1
  41. package/src/codegen.ts +191 -64
  42. package/src/config.ts +140 -109
  43. package/src/coverage.ts +837 -0
  44. package/src/dependencies.ts +6 -40
  45. package/src/dfid.ts +618 -0
  46. package/src/environment.ts +240 -118
  47. package/src/errors.ts +70 -55
  48. package/src/evaluate.ts +632 -298
  49. package/src/exit-codes.ts +37 -3
  50. package/src/fingerprints.ts +10 -10
  51. package/src/index.ts +3 -0
  52. package/src/instances.ts +79 -11
  53. package/src/java-overrides.ts +2 -12
  54. package/src/json-reader.ts +456 -0
  55. package/src/json.ts +262 -139
  56. package/src/levels.ts +2 -3
  57. package/src/lexer.ts +17 -26
  58. package/src/liveness-checker.ts +10 -18
  59. package/src/liveness.ts +121 -49
  60. package/src/obligations/action.ts +4 -28
  61. package/src/obligations/anonymize.ts +84 -80
  62. package/src/obligations/equality.ts +1 -1
  63. package/src/obligations/expression.ts +2 -19
  64. package/src/obligations/format.ts +1 -9
  65. package/src/obligations/generate.ts +1 -11
  66. package/src/obligations/index.ts +0 -11
  67. package/src/obligations/levels.ts +4 -8
  68. package/src/obligations/module.ts +1 -15
  69. package/src/obligations/normalize.ts +5 -24
  70. package/src/obligations/operators.ts +1 -2
  71. package/src/obligations/pragma.ts +1 -10
  72. package/src/obligations/printer.ts +47 -46
  73. package/src/obligations/proof.ts +1 -5
  74. package/src/obligations/regroup.ts +1 -4
  75. package/src/obligations/simplify.ts +3 -14
  76. package/src/obligations/source.ts +1 -21
  77. package/src/obligations/subexpression.ts +5 -11
  78. package/src/obligations/substitution.ts +1 -3
  79. package/src/obligations/temporal.ts +8 -14
  80. package/src/obligations/tuples.ts +3 -9
  81. package/src/parallel-worker.ts +31 -38
  82. package/src/parallel.ts +41 -17
  83. package/src/parser.ts +436 -90
  84. package/src/pcal/ast.ts +7 -28
  85. package/src/pcal/parse.ts +11 -39
  86. package/src/pcal/tokenize.ts +4 -20
  87. package/src/pcal/translate.ts +10 -42
  88. package/src/pcal/validate.ts +3 -21
  89. package/src/pretty-print.ts +1 -2
  90. package/src/prover/decide-pool.ts +5 -10
  91. package/src/prover/deciders.ts +0 -4
  92. package/src/prover/first-order.ts +0 -11
  93. package/src/prover/isabelle/decide.ts +0 -6
  94. package/src/prover/isabelle/encode.ts +11 -23
  95. package/src/prover/isabelle/isar/inner-syntax.ts +108 -114
  96. package/src/prover/isabelle/isar/method.ts +25 -38
  97. package/src/prover/isabelle/isar/proof.ts +1 -10
  98. package/src/prover/isabelle/isar/statement.ts +1 -6
  99. package/src/prover/isabelle/isar/theory.ts +15 -26
  100. package/src/prover/isabelle/isar/type-check.ts +11 -25
  101. package/src/prover/isabelle/provers/blast/blast.ts +10 -41
  102. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  103. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  104. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  105. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  106. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  107. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  108. package/src/prover/isabelle/provers/classical.ts +14 -42
  109. package/src/prover/isabelle/provers/hypsubst.ts +11 -25
  110. package/src/prover/isabelle/pure/bicompose.ts +16 -13
  111. package/src/prover/isabelle/pure/consts.ts +1 -7
  112. package/src/prover/isabelle/pure/conv.ts +1 -9
  113. package/src/prover/isabelle/pure/drule.ts +24 -40
  114. package/src/prover/isabelle/pure/envir.ts +3 -52
  115. package/src/prover/isabelle/pure/goal.ts +1 -7
  116. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  117. package/src/prover/isabelle/pure/list.ts +0 -3
  118. package/src/prover/isabelle/pure/logic.ts +1 -14
  119. package/src/prover/isabelle/pure/name.ts +2 -9
  120. package/src/prover/isabelle/pure/net.ts +3 -59
  121. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  122. package/src/prover/isabelle/pure/pattern.ts +2 -19
  123. package/src/prover/isabelle/pure/raw-simplifier.ts +13 -49
  124. package/src/prover/isabelle/pure/rewriter.ts +26 -58
  125. package/src/prover/isabelle/pure/search.ts +3 -10
  126. package/src/prover/isabelle/pure/seq.ts +1 -10
  127. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  128. package/src/prover/isabelle/pure/table.ts +1 -31
  129. package/src/prover/isabelle/pure/tactic.ts +12 -22
  130. package/src/prover/isabelle/pure/tactical.ts +6 -12
  131. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  132. package/src/prover/isabelle/pure/term.ts +2 -43
  133. package/src/prover/isabelle/pure/thm.ts +13 -36
  134. package/src/prover/isabelle/pure/type.ts +2 -15
  135. package/src/prover/isabelle/pure/unify.ts +20 -30
  136. package/src/prover/isabelle/pure/variable.ts +3 -7
  137. package/src/prover/isabelle/tla/classical-setup.ts +9 -19
  138. package/src/prover/isabelle/tla/context.ts +8 -16
  139. package/src/prover/isabelle/tla/logic.ts +4 -11
  140. package/src/prover/isabelle/tla/simpdata.ts +46 -34
  141. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  142. package/src/prover/ocaml.ts +0 -6
  143. package/src/prover/prep/action.ts +4 -36
  144. package/src/prover/prep/enabled-axioms.ts +12 -19
  145. package/src/prover/prep/fingerprint.ts +0 -16
  146. package/src/prover/prep/level-comparison.ts +8 -12
  147. package/src/prover/prep/md5.ts +0 -2
  148. package/src/prover/prep/methods.ts +9 -36
  149. package/src/prover/prep/normalize.ts +4 -28
  150. package/src/prover/prove-worker.ts +0 -2
  151. package/src/prover/prove.ts +0 -36
  152. package/src/prover/ptl/decide.ts +7 -12
  153. package/src/prover/ptl/encode.ts +14 -36
  154. package/src/prover/ptl/sat.ts +24 -32
  155. package/src/prover/ptl/tableau.ts +12 -26
  156. package/src/prover/smt/axioms.ts +0 -7
  157. package/src/prover/smt/context.ts +19 -26
  158. package/src/prover/smt/data.ts +51 -54
  159. package/src/prover/smt/encode.ts +14 -35
  160. package/src/prover/smt/extensionality.ts +0 -10
  161. package/src/prover/smt/flatten.ts +3 -22
  162. package/src/prover/smt/format.ts +5 -10
  163. package/src/prover/smt/instances.ts +0 -10
  164. package/src/prover/smt/rewrite.ts +66 -101
  165. package/src/prover/smt/solver/act-cache.ts +0 -15
  166. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  167. package/src/prover/smt/solver/array.ts +1 -3
  168. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  169. package/src/prover/smt/solver/ast-lt.ts +1 -11
  170. package/src/prover/smt/solver/ast-util.ts +1 -6
  171. package/src/prover/smt/solver/ast.ts +1 -143
  172. package/src/prover/smt/solver/auf-solver.ts +6 -39
  173. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  174. package/src/prover/smt/solver/cg-table.ts +1 -18
  175. package/src/prover/smt/solver/clause.ts +1 -27
  176. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  177. package/src/prover/smt/solver/context.ts +4 -61
  178. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  179. package/src/prover/smt/solver/der.ts +2 -21
  180. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  181. package/src/prover/smt/solver/e-matching.ts +3 -34
  182. package/src/prover/smt/solver/enode.ts +1 -21
  183. package/src/prover/smt/solver/expr-ref.ts +1 -5
  184. package/src/prover/smt/solver/expr-safe-replace.ts +0 -5
  185. package/src/prover/smt/solver/fingerprints.ts +1 -12
  186. package/src/prover/smt/solver/flat-literals.ts +1 -9
  187. package/src/prover/smt/solver/goal.ts +2 -14
  188. package/src/prover/smt/solver/hash.ts +0 -8
  189. package/src/prover/smt/solver/hashtable.ts +1 -12
  190. package/src/prover/smt/solver/internalizer.ts +6 -98
  191. package/src/prover/smt/solver/lbool.ts +1 -2
  192. package/src/prover/smt/solver/literal.ts +0 -3
  193. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  194. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  195. package/src/prover/smt/solver/lp/containers.ts +12 -30
  196. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  197. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  198. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  199. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  200. package/src/prover/smt/solver/lp/dioph-eq.ts +12 -98
  201. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  202. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  203. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  204. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  205. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  206. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  207. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  208. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  209. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  210. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  211. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  212. package/src/prover/smt/solver/lp/nex.ts +1 -6
  213. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  214. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  215. package/src/prover/smt/solver/lp/nla-core.ts +35 -130
  216. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  217. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  218. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  220. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  221. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  222. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  223. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  224. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  225. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  226. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  227. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  228. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  229. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  230. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  231. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  232. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  233. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  234. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  235. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  236. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  237. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  238. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  239. package/src/prover/smt/solver/mam-compiler.ts +14 -56
  240. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  241. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  242. package/src/prover/smt/solver/model-checker.ts +2 -36
  243. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  244. package/src/prover/smt/solver/model-finder.ts +3 -15
  245. package/src/prover/smt/solver/model-generator.ts +1 -12
  246. package/src/prover/smt/solver/model-macro-solver.ts +12 -69
  247. package/src/prover/smt/solver/nlsat/algebraic.ts +55 -151
  248. package/src/prover/smt/solver/nlsat/atoms.ts +5 -19
  249. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  250. package/src/prover/smt/solver/nlsat/explain.ts +3 -47
  251. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  252. package/src/prover/smt/solver/nlsat/levelwise.ts +48 -129
  253. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  254. package/src/prover/smt/solver/nlsat/polynomial.ts +17 -156
  255. package/src/prover/smt/solver/nlsat/solver.ts +7 -67
  256. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  257. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -44
  258. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  259. package/src/prover/smt/solver/nnf.ts +3 -38
  260. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  261. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  262. package/src/prover/smt/solver/propagate-values.ts +1 -10
  263. package/src/prover/smt/solver/proto-model.ts +3 -48
  264. package/src/prover/smt/solver/pull-quant.ts +1 -12
  265. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  266. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  267. package/src/prover/smt/solver/qe-lite.ts +3 -33
  268. package/src/prover/smt/solver/qi-queue.ts +1 -16
  269. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  270. package/src/prover/smt/solver/quantifier-analyzer.ts +17 -37
  271. package/src/prover/smt/solver/quantifier-manager.ts +1 -8
  272. package/src/prover/smt/solver/random-gen.ts +1 -2
  273. package/src/prover/smt/solver/rational.ts +1 -8
  274. package/src/prover/smt/solver/ref-vector.ts +1 -6
  275. package/src/prover/smt/solver/relevancy.ts +2 -15
  276. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  277. package/src/prover/smt/solver/rewriter.ts +3 -85
  278. package/src/prover/smt/solver/rlimit.ts +2 -20
  279. package/src/prover/smt/solver/smtlib-parser.ts +2 -37
  280. package/src/prover/smt/solver/solver.ts +23 -34
  281. package/src/prover/smt/solver/sort.ts +1 -5
  282. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  283. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  284. package/src/prover/smt/solver/theory-lra-bounds.ts +0 -5
  285. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  286. package/src/prover/smt/solver/theory-lra-internalize.ts +1 -27
  287. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  288. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  289. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  290. package/src/prover/smt/solver/theory-lra.ts +1 -8
  291. package/src/prover/smt/solver/var-subst.ts +2 -26
  292. package/src/prover/smt/table.ts +0 -8
  293. package/src/prover/tlapm/cache.ts +20 -25
  294. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  295. package/src/prover/tlapm/tlapm.ts +12 -17
  296. package/src/prover/verdict.ts +0 -2
  297. package/src/prover/zenon/check/check.ts +0 -9
  298. package/src/prover/zenon/check/definitions.ts +5 -15
  299. package/src/prover/zenon/check/equality.ts +0 -8
  300. package/src/prover/zenon/check/functions.ts +0 -4
  301. package/src/prover/zenon/check/keys.ts +0 -7
  302. package/src/prover/zenon/check/propositional.ts +0 -3
  303. package/src/prover/zenon/check/records.ts +0 -5
  304. package/src/prover/zenon/check/relations.ts +0 -13
  305. package/src/prover/zenon/check/rewrites.ts +0 -6
  306. package/src/prover/zenon/check/sets.ts +0 -3
  307. package/src/prover/zenon/check/terms.ts +0 -17
  308. package/src/prover/zenon/check/tla.ts +0 -6
  309. package/src/prover/zenon/decide.ts +0 -12
  310. package/src/prover/zenon/encode.ts +1 -8
  311. package/src/prover/zenon/eqrel.ts +0 -13
  312. package/src/prover/zenon/equality-rules.ts +0 -4
  313. package/src/prover/zenon/expr.ts +1 -26
  314. package/src/prover/zenon/index-table.ts +17 -38
  315. package/src/prover/zenon/isar-case.ts +9 -19
  316. package/src/prover/zenon/isar.ts +1 -29
  317. package/src/prover/zenon/limits.ts +0 -4
  318. package/src/prover/zenon/llproof.ts +0 -9
  319. package/src/prover/zenon/mltoll.ts +54 -76
  320. package/src/prover/zenon/node.ts +1 -11
  321. package/src/prover/zenon/ocaml.ts +1 -17
  322. package/src/prover/zenon/parse.ts +2 -7
  323. package/src/prover/zenon/phrase.ts +1 -11
  324. package/src/prover/zenon/proof.ts +0 -9
  325. package/src/prover/zenon/propositional-rules.ts +0 -5
  326. package/src/prover/zenon/rules.ts +2 -6
  327. package/src/prover/zenon/search.ts +1 -17
  328. package/src/prover/zenon/tla/functions.ts +57 -29
  329. package/src/prover/zenon/tla/llproof.ts +63 -70
  330. package/src/prover/zenon/tla/records.ts +56 -27
  331. package/src/prover/zenon/tla/rewrites.ts +12 -19
  332. package/src/prover/zenon/tla/sets.ts +68 -39
  333. package/src/prover/zenon/tla/terms.ts +0 -6
  334. package/src/prover/zenon/tla/tla.ts +59 -58
  335. package/src/randomization.ts +84 -35
  336. package/src/resolve.ts +18 -60
  337. package/src/runtime.ts +11 -4
  338. package/src/sany/builtins.ts +3 -4
  339. package/src/sany/generator.ts +128 -176
  340. package/src/sany/levels.ts +6 -30
  341. package/src/sany/lexer.ts +7 -23
  342. package/src/sany/linter.ts +31 -29
  343. package/src/sany/modules.ts +1 -5
  344. package/src/sany/nodes.ts +0 -31
  345. package/src/sany/parse-error.ts +39 -117
  346. package/src/sany/report.ts +29 -63
  347. package/src/sany/selectors.ts +15 -39
  348. package/src/sany/source.ts +1 -17
  349. package/src/sany/xml.ts +13 -63
  350. package/src/search.ts +533 -174
  351. package/src/simulate.ts +694 -0
  352. package/src/spec-description.ts +166 -48
  353. package/src/standard-definitions.ts +2 -3
  354. package/src/standard-modules.ts +264 -68
  355. package/src/state-graph.ts +51 -18
  356. package/src/subexpressions.ts +31 -5
  357. package/src/substitution-levels.ts +2 -3
  358. package/src/successors.ts +267 -77
  359. package/src/symmetry.ts +31 -8
  360. package/src/tableau.ts +27 -24
  361. package/src/tlc/fingerprint.ts +183 -61
  362. package/src/tlc/jar-data.ts +113 -6
  363. package/src/tlc/messages.ts +122 -37
  364. package/src/tlc/order.ts +33 -38
  365. package/src/tlc/random.ts +16 -16
  366. package/src/tlc/replay.ts +563 -211
  367. package/src/tlc/summary.ts +2 -4
  368. package/src/tlc/tlc-operators.ts +81 -36
  369. package/src/tlc/tlcext-operators.ts +138 -117
  370. package/src/tlc/trace-spec.ts +273 -0
  371. package/src/tlc/value-stream.ts +143 -0
  372. package/src/tlc/version.ts +2 -4
  373. package/src/transfer.ts +22 -25
  374. package/src/typescript/actions.ts +481 -0
  375. package/src/typescript/collections.ts +600 -0
  376. package/src/typescript/compile.ts +65 -0
  377. package/src/typescript/context.ts +94 -0
  378. package/src/typescript/emit.ts +121 -0
  379. package/src/typescript/expressions.ts +496 -0
  380. package/src/typescript/formula.ts +152 -0
  381. package/src/typescript/functions.ts +284 -0
  382. package/src/typescript/model.ts +163 -0
  383. package/src/typescript/names.ts +114 -0
  384. package/src/typescript/program.ts +48 -0
  385. package/src/typescript/properties.ts +139 -0
  386. package/src/typescript/scope.ts +112 -0
  387. package/src/typescript/steps.ts +165 -0
  388. package/src/typescript/types.ts +171 -0
  389. package/src/values.ts +832 -255
  390. package/src/worker.ts +7 -8
@@ -1,8 +1,4 @@
1
1
  // Ported from Zenon's mlproof.ml, as shipped in tlapm. Copyright 2004 INRIA, see LICENSE.
2
- //
3
- // The proofs that the search builds and the checker reads. Each rule takes a fixed number of
4
- // arguments, or at least a fixed number, so a rule application can't have the wrong arity. The
5
- // rules of the TLA+ extension, Zenon's Ext, sit beside the core rules: their names don't clash.
6
2
 
7
3
  import type { Expr } from "./expr";
8
4
  import type { Definition } from "./parse";
@@ -14,7 +10,6 @@ type Five<Term> = [Term, Term, Term, Term, Term];
14
10
  type Six<Term> = [Term, Term, Term, Term, Term, Term];
15
11
  type Seven<Term> = [Term, Term, Term, Term, Term, Term, Term];
16
12
 
17
- // The arguments of each rule that names neither a relation nor a definition.
18
13
  interface PlainRuleArgs<Term> {
19
14
  close: [Term];
20
15
  false: [];
@@ -141,7 +136,6 @@ interface PlainRuleArgs<Term> {
141
136
  tuple_len: Five<Term>;
142
137
  }
143
138
 
144
- // The rules that hold for any relation that the hypotheses make reflexive or symmetric.
145
139
  interface RelationRuleArgs<Term> {
146
140
  close_refl: [Term];
147
141
  close_sym: Two<Term>;
@@ -167,14 +161,11 @@ type RelationRules<Term> = {
167
161
  };
168
162
  };
169
163
 
170
- // A rule application, as in Zenon's Mlproof.rule. "definition" unfolds `definition`.
171
164
  export type Rule<Term = Expr> =
172
165
  | PlainRules<Term>[PlainRuleName]
173
166
  | RelationRules<Term>[RelationRuleName]
174
167
  | { name: "definition"; definition: Definition; args: Two<Term> };
175
168
 
176
- // A proof of the formulas in `conclusions`: the node's rule applied to `uses`, with a subproof for
177
- // each of its branches.
178
169
  export interface Proof<Term = Expr> {
179
170
  conclusions: Term[];
180
171
  rule: Rule<Term>;
@@ -1,6 +1,4 @@
1
1
  // Ported from Zenon's prove.ml, as shipped in tlapm. Copyright 2002 INRIA, see LICENSE.
2
- //
3
- // The rules for connectives and quantifiers, closing a branch, and unfolding definitions.
4
2
 
5
3
  import { getStringValue } from "./equality-rules";
6
4
  import { isApp, type Expr, type Expressions } from "./expr";
@@ -9,7 +7,6 @@ import type { Definition } from "./parse";
9
7
  import { makeRelationRule, makeRule, type Rule } from "./proof";
10
8
  import { makeNode, type RuleResult, type SearchRule } from "./rules";
11
9
 
12
- // Zenon's is_conj and is_disj: how many more conjuncts or disjuncts a formula needs to reach m.
13
10
  const countConjuncts = (formula: Expr, needed: number): number => {
14
11
  if (needed <= 0) return 0;
15
12
  if (formula.kind === "and")
@@ -350,8 +347,6 @@ export const addUnfold: SearchRule = (context, queue, formula, goalness) => {
350
347
  wrap,
351
348
  );
352
349
  };
353
- // Zenon tries applications before variables, each first as the formula itself, then as either
354
- // side of a relation that is reflexive, symmetric or transitive.
355
350
  for (const kind of ["app", "var"]) {
356
351
  if (atom.kind === kind) {
357
352
  const result = tryUnfold(atom, negate);
@@ -1,7 +1,4 @@
1
1
  // Ported from Zenon's prove.ml, as shipped in tlapm. Copyright 2002 INRIA, see LICENSE.
2
- //
3
- // Zenon's newnodes: each rule in turn suggests nodes for a formula added to a branch, until one
4
- // says that the rest don't apply.
5
2
 
6
3
  import type { Relations } from "./eqrel";
7
4
  import {
@@ -12,7 +9,7 @@ import {
12
9
  addSymmetricMatches,
13
10
  addTransitivity,
14
11
  } from "./equality-rules";
15
- import { type Expr, type Expressions } from "./expr";
12
+ import type { Expr, Expressions } from "./expr";
16
13
  import type { Index } from "./index-table";
17
14
  import { insertNode, type Node, type Priority, type Queue } from "./node";
18
15
  import type { Rule } from "./proof";
@@ -62,8 +59,7 @@ const addExtensions: SearchRule = (context, queue, formula, goalness) => {
62
59
  return [insertAll(queue, result.nodes), result.isStopped];
63
60
  };
64
61
 
65
- // Zenon's newnodes_preunif comes after addReflexivity, but it never adds a node: it preunifies a
66
- // formula with its negation, whose heads always differ.
62
+ // Deviation from Zenon: newnodes_preunif is left out because it never adds a node.
67
63
  const RULES: SearchRule[] = [
68
64
  addAbsurd,
69
65
  addClosure,
@@ -1,9 +1,4 @@
1
1
  // Ported from Zenon's prove.ml, as shipped in tlapm. Copyright 2002 INRIA, see LICENSE.
2
- //
3
- // The tableau search. Each formula added to a branch suggests nodes, which wait in the queue by
4
- // priority. The search takes the next node, and refutes each of its branches in turn. A branch is
5
- // closed when it holds a formula and its negation. Zenon's mutually recursive search functions are
6
- // one loop here, with an explicit stack of frames.
7
2
 
8
3
  import { TlaZenonError } from "../../errors";
9
4
  import { difference, isApp, isDisjoint, isMeta, union, type Expr } from "./expr";
@@ -23,7 +18,6 @@ const isTrivial = (context: SearchContext, formula: Expr) =>
23
18
  formula.args[0] === formula.args[1] &&
24
19
  context.relations.isReflexive(formula.symbol));
25
20
 
26
- // Zenon's reduce_list: drops the formulas a branch already has, and reverses the rest.
27
21
  const reduceBranch = (context: SearchContext, branch: Expr[]) => {
28
22
  const exprs = context.exprs;
29
23
  const index = context.index;
@@ -138,19 +132,14 @@ interface Frame {
138
132
  interface SearchStatistics {
139
133
  inferences: number;
140
134
  proofNodes: number;
141
- // The proofs that closed another branch from the lemma cache. Zenon counts the uses in mlrefc and
142
- // prints each of these proofs once, as a lemma.
143
135
  reusedProofs: Set<Proof>;
144
136
  }
145
137
 
146
138
  export type SearchFailure = "exhausted" | "time limit" | "memory limit" | "aborted";
147
139
 
148
- // Zenon gives up once its heap passes 1 GB. The port bounds the nodes that the queues of the
149
- // current branch hold instead. On the corpus files where Zenon runs out of memory, its heap passes
150
- // 1 GB with 1.9 to 5.5 million of them, and no proof that Zenon finds needs more than 1.3 million.
140
+ // Deviation from Zenon, which gives up at a 1 GB heap: its heap passes that with 1.9 million queued nodes.
151
141
  const MAX_QUEUED_NODES = 1_900_000;
152
142
 
153
- // The proof of the hypotheses' inconsistency, or why the search gave up.
154
143
  export const search = (
155
144
  context: SearchContext,
156
145
  definitions: Definition[],
@@ -192,8 +181,6 @@ export const search = (
192
181
  return proof;
193
182
  };
194
183
 
195
- // Zenon's next_branch and unwind: descend into the next open branch of a node, or close the node
196
- // and pop frames until one has an open branch left.
197
184
  const advance = (
198
185
  searchNode: Node,
199
186
  nodeQueue: Queue,
@@ -227,8 +214,6 @@ export const search = (
227
214
  }
228
215
  };
229
216
 
230
- // Pops the frames that the proof closes. Returns the proof when it closes the root, and leaves the
231
- // frame to continue on top of the stack otherwise, with the proof recorded.
232
217
  const unwind = (proof: Proof): Proof | undefined => {
233
218
  for (;;) {
234
219
  const frame = stack.pop();
@@ -267,7 +252,6 @@ export const search = (
267
252
  if (result !== undefined) return result;
268
253
  continue;
269
254
  }
270
- // Zenon's next_node: the next node whose branches all add something new.
271
255
  for (;;) {
272
256
  statistics.inferences++;
273
257
  const removed = removeNode(queue);
@@ -1,10 +1,8 @@
1
1
  // Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
2
- //
3
- // The rules for functions: membership in a function set, isAFcn and function equality.
4
2
 
5
- import { isApp, type Expr } from "../expr";
3
+ import { isApp } from "../expr";
6
4
  import type { Priority } from "../node";
7
- import { makeRule, type Rule } from "../proof";
5
+ import { makeRule } from "../proof";
8
6
  import {
9
7
  domain,
10
8
  equal,
@@ -22,8 +20,6 @@ export const getFunctionSetNodes = (literal: Literal): Item[] | undefined => {
22
20
  const formula = literal.formula;
23
21
  const isNegated = literal.isNegated;
24
22
  const relation = literal.relation;
25
- const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
26
- makeExtensionNode(literal, priority, rule, branches);
27
23
  if (relation?.symbol === "TLA.in") {
28
24
  const element = relation.args[0];
29
25
  const set = relation.args[1];
@@ -31,8 +27,8 @@ export const getFunctionSetNodes = (literal: Literal): Item[] | undefined => {
31
27
  const fcn = element;
32
28
  const source = set.args[0];
33
29
  const target = set.args[1];
34
- const isFcn = exprs.eapp("TLA.isAFcn", [fcn]);
35
- const hasDomain = equal(exprs, domain(exprs, fcn), source);
30
+ const fcnFormula = exprs.eapp("TLA.isAFcn", [fcn]);
31
+ const domainFormula = equal(exprs, domain(exprs, fcn), source);
36
32
  const bound = exprs.newVar();
37
33
  const maps = exprs.eall(
38
34
  bound,
@@ -43,21 +39,32 @@ export const getFunctionSetNodes = (literal: Literal): Item[] | undefined => {
43
39
  ),
44
40
  );
45
41
  if (!isNegated) {
46
- const rule = makeRule("in_funcset", [formula, isFcn, hasDomain, maps, fcn, source, target]);
42
+ const rule = makeRule("in_funcset", [
43
+ formula,
44
+ fcnFormula,
45
+ domainFormula,
46
+ maps,
47
+ fcn,
48
+ source,
49
+ target,
50
+ ]);
47
51
  return [
48
- ...node("arity", rule, [[isFcn, hasDomain]]),
49
- ...node({ instance: maps }, rule, [[isFcn, hasDomain, maps]]),
52
+ ...makeExtensionNode(literal, "arity", rule, [[fcnFormula, domainFormula]]),
53
+ ...makeExtensionNode(literal, { instance: maps }, rule, [
54
+ [fcnFormula, domainFormula, maps],
55
+ ]),
50
56
  ];
51
57
  }
52
- const notFcn = exprs.enot(isFcn);
53
- const notDomain = exprs.enot(hasDomain);
58
+ const notFcn = exprs.enot(fcnFormula);
59
+ const notDomain = exprs.enot(domainFormula);
54
60
  const notMaps = exprs.enot(maps);
55
61
  const priority: Priority =
56
62
  fcn.kind === "app" && FUNCTION_CONSTRUCTORS.includes(fcn.symbol)
57
63
  ? "arity"
58
64
  : { instance: notMaps };
59
65
  const shortcut = isApp(fcn, "TLA.except", 3)
60
- ? node(
66
+ ? makeExtensionNode(
67
+ literal,
61
68
  "arity",
62
69
  makeRule("except_notin_funcset", [
63
70
  formula,
@@ -77,7 +84,8 @@ export const getFunctionSetNodes = (literal: Literal): Item[] | undefined => {
77
84
  : [];
78
85
  return [
79
86
  ...shortcut,
80
- ...node(
87
+ ...makeExtensionNode(
88
+ literal,
81
89
  priority,
82
90
  makeRule("notin_funcset", [formula, notFcn, notDomain, notMaps, fcn, source, target]),
83
91
  [[notFcn], [notDomain], [notMaps]],
@@ -94,22 +102,36 @@ export const getFunctionNodes = (literal: Literal): Item[] | undefined => {
94
102
  const isNegated = literal.isNegated;
95
103
  const atom = literal.atom;
96
104
  const relation = literal.relation;
97
- const node = (priority: Priority, rule: Rule, branches: Expr[][]) =>
98
- makeExtensionNode(literal, priority, rule, branches);
99
105
  if (isNegated && isApp(atom, "TLA.isAFcn", 1)) {
100
106
  const fcn = atom.args[0];
101
107
  if (isApp(fcn, "TLA.Fcn", 2))
102
- return node("prop", makeRule("notisafcn_fcn", [formula, fcn.args[0], fcn.args[1]]), []);
108
+ return makeExtensionNode(
109
+ literal,
110
+ "prop",
111
+ makeRule("notisafcn_fcn", [formula, fcn.args[0], fcn.args[1]]),
112
+ [],
113
+ );
103
114
  if (isApp(fcn, "TLA.except", 3))
104
- return node(
115
+ return makeExtensionNode(
116
+ literal,
105
117
  "prop",
106
118
  makeRule("notisafcn_except", [formula, fcn.args[0], fcn.args[1], fcn.args[2]]),
107
119
  [],
108
120
  );
109
121
  if (isApp(fcn, "TLA.oneArg", 2))
110
- return node("prop", makeRule("notisafcn_onearg", [formula, fcn.args[0], fcn.args[1]]), []);
122
+ return makeExtensionNode(
123
+ literal,
124
+ "prop",
125
+ makeRule("notisafcn_onearg", [formula, fcn.args[0], fcn.args[1]]),
126
+ [],
127
+ );
111
128
  if (isApp(fcn, "TLA.extend", 2))
112
- return node("prop", makeRule("notisafcn_extend", [formula, fcn.args[0], fcn.args[1]]), []);
129
+ return makeExtensionNode(
130
+ literal,
131
+ "prop",
132
+ makeRule("notisafcn_extend", [formula, fcn.args[0], fcn.args[1]]),
133
+ [],
134
+ );
113
135
  }
114
136
  if (relation?.symbol !== "=") return undefined;
115
137
  const left = relation.args[0];
@@ -119,15 +141,18 @@ export const getFunctionNodes = (literal: Literal): Item[] | undefined => {
119
141
  const sameDomain = equal(exprs, domain(exprs, left), domain(exprs, right));
120
142
  const sameValue = equal(exprs, fapply(exprs, left, bound), fapply(exprs, right, bound));
121
143
  if (!isNegated) {
122
- const isFcn = exprs.eequiv(
144
+ const fcnEquivalence = exprs.eequiv(
123
145
  exprs.eapp("TLA.isAFcn", [left]),
124
146
  exprs.eapp("TLA.isAFcn", [right]),
125
147
  );
126
148
  const values = exprs.eall(bound, "", sameValue);
127
- const result = exprs.eand(exprs.eand(isFcn, sameDomain), values);
128
- return node({ instance: values }, makeRule("funequal", [formula, result, left, right]), [
129
- [result],
130
- ]);
149
+ const result = exprs.eand(exprs.eand(fcnEquivalence, sameDomain), values);
150
+ return makeExtensionNode(
151
+ literal,
152
+ { instance: values },
153
+ makeRule("funequal", [formula, result, left, right]),
154
+ [[result]],
155
+ );
131
156
  }
132
157
  const values = exprs.eall(
133
158
  bound,
@@ -143,9 +168,12 @@ export const getFunctionNodes = (literal: Literal): Item[] | undefined => {
143
168
  values,
144
169
  ),
145
170
  );
146
- return node({ instance: values }, makeRule("notfunequal", [formula, result, left, right]), [
147
- [result],
148
- ]);
171
+ return makeExtensionNode(
172
+ literal,
173
+ { instance: values },
174
+ makeRule("notfunequal", [formula, result, left, right]),
175
+ [[result]],
176
+ );
149
177
  }
150
178
  return undefined;
151
179
  };
@@ -1,14 +1,10 @@
1
1
  // Ported from Zenon's ext_tla.ml, as shipped in tlapm. Copyright 2008 INRIA, see LICENSE.
2
- //
3
- // Zenon's to_llproof for the TLA+ extension: each rule becomes an extension rule of the low-level
4
- // proof, named after the lemma in Zenon.thy that justifies it.
5
2
 
6
3
  import { TlaZenonError } from "../../../errors";
7
4
  import { difference, union, type Expr, type Expressions } from "../expr";
8
5
  import { connect, type Lemma, type LlProof, type LlRule } from "../llproof";
9
6
  import type { MlProof, Translated } from "../mltoll";
10
7
 
11
- // The lemma's name, the terms it's instantiated with, the conclusions it uses and its branches.
12
8
  type LlArgs = [string, Expr[], Expr[], Expr[][]];
13
9
 
14
10
  type Shape = (name: string, args: Expr[]) => LlArgs;
@@ -72,7 +68,6 @@ const binbeta: Shape = (name, args) => {
72
68
  return [`zenon_${name}`, rest, [first, second], [[hypothesisA], [hypothesisB]]];
73
69
  };
74
70
 
75
- // A conclusion, two terms and then the hypotheses, in one branch or one branch each.
76
71
  const withTerms =
77
72
  (isSplit: boolean): Shape =>
78
73
  (name, args) => {
@@ -86,7 +81,6 @@ const withTerms =
86
81
  ];
87
82
  };
88
83
 
89
- // A conclusion and then the hypotheses, in one branch or one branch each.
90
84
  const withoutTerms =
91
85
  (isSplit: boolean): Shape =>
92
86
  (name, args) => {
@@ -107,7 +101,6 @@ const getCaseBranches = (args: Expr[]): Expr[][] =>
107
101
  : [args]
108
102
  : [args.slice(0, 2), ...getCaseBranches(args.slice(2))];
109
103
 
110
- // Zenon's to_llargs, by rule name. The rules missing here take one hypothesis.
111
104
  const SHAPES: Record<string, Shape> = {
112
105
  in_emptyset: (name, args) => [`zenon_${name}`, args.slice(1), args.slice(0, 1), []],
113
106
  in_nat_0: close,
@@ -194,14 +187,12 @@ const SHAPES: Record<string, Shape> = {
194
187
  record_notisafcn: close,
195
188
  };
196
189
 
197
- // Zenon's Ext_tla.to_llproof, for a rule of the extension and its translated subproofs.
198
190
  export const getTlaLlProof = (
199
191
  translateExpr: (expression: Expr) => Expr,
200
192
  exprs: Expressions,
201
193
  proof: MlProof,
202
194
  subproofs: Translated[],
203
195
  ): Translated => {
204
- const tr = translateExpr;
205
196
  const rule = proof.rule;
206
197
  const member = (element: Expr, set: Expr) => exprs.eapp("TLA.in", [element, set]);
207
198
  const equal = (left: Expr, right: Expr) => exprs.eapp("=", [left, right]);
@@ -213,18 +204,24 @@ export const getTlaLlProof = (
213
204
  branches: Expr[][],
214
205
  nodeSubproofs: LlProof[],
215
206
  ): LlProof => ({
216
- conclusions: conclusions.map(tr),
207
+ conclusions: conclusions.map(translateExpr),
217
208
  rule: {
218
209
  kind: "extension",
219
210
  name,
220
- args: args.map(tr),
221
- conclusions: ruleConclusions.map(tr),
222
- branches: branches.map((branch) => branch.map(tr)),
211
+ args: args.map(translateExpr),
212
+ conclusions: ruleConclusions.map(translateExpr),
213
+ branches: branches.map((branch) => branch.map(translateExpr)),
223
214
  },
224
215
  subproofs: nodeSubproofs,
225
216
  });
226
217
 
227
- // The membership in an enumerated set, one element at a time.
218
+ const splitSet = (set: Expr, isSetOf: boolean) =>
219
+ set.kind === "app" &&
220
+ set.symbol === (isSetOf ? "TLA.set" : "TLA.addElt") &&
221
+ set.args.length >= (isSetOf ? 1 : 2)
222
+ ? [set.args[0], isSetOf ? exprs.eapp("TLA.set", set.args.slice(1)) : set.args[1]]
223
+ : undefined;
224
+
228
225
  const getMembership = (
229
226
  element: Expr,
230
227
  set: Expr,
@@ -240,12 +237,7 @@ export const getTlaLlProof = (
240
237
  extension(conclusions, "zenon_in_emptyset", [element], [member(element, set)], [], []),
241
238
  [],
242
239
  ];
243
- const split =
244
- set.kind === "app" &&
245
- set.symbol === (isSetOf ? "TLA.set" : "TLA.addElt") &&
246
- set.args.length >= (isSetOf ? 1 : 2)
247
- ? [set.args[0], isSetOf ? exprs.eapp("TLA.set", set.args.slice(1)) : set.args[1]]
248
- : undefined;
240
+ const split = splitSet(set, isSetOf);
249
241
  const first = remaining[0];
250
242
  if (split === undefined || first === undefined) {
251
243
  if (!isSetOf && remaining.length === 1) return remaining[0];
@@ -254,13 +246,13 @@ export const getTlaLlProof = (
254
246
  const value = split[0];
255
247
  const rest = split[1];
256
248
  const conclusion = member(element, set);
257
- const isValue = equal(element, value);
258
- const isInRest = member(element, rest);
249
+ const valueEquality = equal(element, value);
250
+ const restMembership = member(element, rest);
259
251
  const next = getMembership(
260
252
  element,
261
253
  rest,
262
254
  remaining.slice(1),
263
- [isInRest, ...conclusions],
255
+ [restMembership, ...conclusions],
264
256
  isSetOf,
265
257
  );
266
258
  const extras = difference(union(first[1], next[1]), conclusions);
@@ -270,14 +262,13 @@ export const getTlaLlProof = (
270
262
  "zenon_in_addElt",
271
263
  [element, value, rest],
272
264
  [conclusion],
273
- [[isValue], [isInRest]],
265
+ [[valueEquality], [restMembership]],
274
266
  [first[0], next[0]],
275
267
  ),
276
268
  extras,
277
269
  ];
278
270
  };
279
271
 
280
- // The non-membership in an enumerated set, one element at a time.
281
272
  const getNonMembership = (
282
273
  element: Expr,
283
274
  set: Expr,
@@ -285,23 +276,18 @@ export const getTlaLlProof = (
285
276
  conclusions: Expr[],
286
277
  isSetOf: boolean,
287
278
  ): Translated => {
288
- const split =
289
- set.kind === "app" &&
290
- set.symbol === (isSetOf ? "TLA.set" : "TLA.addElt") &&
291
- set.args.length >= (isSetOf ? 1 : 2)
292
- ? [set.args[0], isSetOf ? exprs.eapp("TLA.set", set.args.slice(1)) : set.args[1]]
293
- : undefined;
279
+ const split = splitSet(set, isSetOf);
294
280
  if (split === undefined) return sub;
295
281
  const value = split[0];
296
282
  const rest = split[1];
297
283
  const conclusion = exprs.enot(member(element, set));
298
- const isNotValue = exprs.enot(equal(element, value));
299
- const isNotInRest = exprs.enot(member(element, rest));
284
+ const valueInequality = exprs.enot(equal(element, value));
285
+ const restNonMembership = exprs.enot(member(element, rest));
300
286
  const next = getNonMembership(
301
287
  element,
302
288
  rest,
303
289
  sub,
304
- [isNotValue, isNotInRest, ...conclusions],
290
+ [valueInequality, restNonMembership, ...conclusions],
305
291
  isSetOf,
306
292
  );
307
293
  const extras = difference(next[1], conclusions);
@@ -311,7 +297,7 @@ export const getTlaLlProof = (
311
297
  "zenon_notin_addElt",
312
298
  [element, value, rest],
313
299
  [conclusion],
314
- [[isNotValue, isNotInRest]],
300
+ [[valueInequality, restNonMembership]],
315
301
  [next[0]],
316
302
  ),
317
303
  extras,
@@ -367,10 +353,9 @@ export const getTlaLlProof = (
367
353
  }
368
354
  };
369
355
 
370
- // Zenon's Ext_tla.postprocess: the lemmas with each $notequiv written as a negated equivalence.
371
356
  export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] => {
372
357
  const cache = new Map<Expr, Expr>();
373
- const pp = (expression: Expr): Expr => {
358
+ const postprocess = (expression: Expr): Expr => {
374
359
  const cached = cache.get(expression);
375
360
  if (cached !== undefined) return cached;
376
361
  const result = ((): Expr => {
@@ -383,35 +368,35 @@ export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] =>
383
368
  throw new TlaZenonError("Zenon: a metavariable in a low-level proof");
384
369
  case "app": {
385
370
  if (expression.symbol !== "$notequiv")
386
- return exprs.eapp(expression.symbol, expression.args.map(pp));
371
+ return exprs.eapp(expression.symbol, expression.args.map(postprocess));
387
372
  if (expression.args.length !== 2)
388
373
  throw new TlaZenonError("Zenon: $notequiv without two arguments");
389
- const right = pp(expression.args[1]);
390
- return exprs.enot(exprs.eequiv(pp(expression.args[0]), right));
374
+ const right = postprocess(expression.args[1]);
375
+ return exprs.enot(exprs.eequiv(postprocess(expression.args[0]), right));
391
376
  }
392
377
  case "not":
393
- return exprs.enot(pp(expression.args[0]));
378
+ return exprs.enot(postprocess(expression.args[0]));
394
379
  case "and":
395
380
  case "or":
396
381
  case "imply":
397
382
  case "equiv": {
398
- const right = pp(expression.args[1]);
399
- return connect(exprs, expression.kind, pp(expression.args[0]), right);
383
+ const right = postprocess(expression.args[1]);
384
+ return connect(exprs, expression.kind, postprocess(expression.args[0]), right);
400
385
  }
401
386
  case "all":
402
- return exprs.eall(expression.args[0], expression.symbol, pp(expression.args[1]));
387
+ return exprs.eall(expression.args[0], expression.symbol, postprocess(expression.args[1]));
403
388
  case "ex":
404
- return exprs.eex(expression.args[0], expression.symbol, pp(expression.args[1]));
389
+ return exprs.eex(expression.args[0], expression.symbol, postprocess(expression.args[1]));
405
390
  case "tau":
406
- return exprs.etau(expression.args[0], expression.symbol, pp(expression.args[1]));
391
+ return exprs.etau(expression.args[0], expression.symbol, postprocess(expression.args[1]));
407
392
  case "lam":
408
- return exprs.elam(expression.args[0], expression.symbol, pp(expression.args[1]));
393
+ return exprs.elam(expression.args[0], expression.symbol, postprocess(expression.args[1]));
409
394
  }
410
395
  })();
411
396
  cache.set(expression, result);
412
397
  return result;
413
398
  };
414
- const ppRule = (rule: LlRule): LlRule => {
399
+ const postprocessRule = (rule: LlRule): LlRule => {
415
400
  switch (rule.kind) {
416
401
  case "false":
417
402
  case "nottrue":
@@ -419,62 +404,70 @@ export const postprocessTla = (exprs: Expressions, lemmas: Lemma[]): Lemma[] =>
419
404
  case "axiom":
420
405
  case "cut":
421
406
  case "notnot":
422
- return { kind: rule.kind, formula: pp(rule.formula) };
407
+ return { kind: rule.kind, formula: postprocess(rule.formula) };
423
408
  case "noteq":
424
- return { kind: "noteq", term: pp(rule.term) };
409
+ return { kind: "noteq", term: postprocess(rule.term) };
425
410
  case "eqsym":
426
411
  case "notequal":
427
- return { kind: rule.kind, left: pp(rule.left), right: pp(rule.right) };
412
+ return { kind: rule.kind, left: postprocess(rule.left), right: postprocess(rule.right) };
428
413
  case "connect":
429
414
  case "notconnect":
430
415
  return {
431
416
  kind: rule.kind,
432
417
  connective: rule.connective,
433
- left: pp(rule.left),
434
- right: pp(rule.right),
418
+ left: postprocess(rule.left),
419
+ right: postprocess(rule.right),
435
420
  };
436
421
  case "ex":
437
422
  case "all":
438
423
  case "notex":
439
424
  case "notall":
440
- return { kind: rule.kind, quantified: pp(rule.quantified), term: pp(rule.term) };
425
+ return {
426
+ kind: rule.kind,
427
+ quantified: postprocess(rule.quantified),
428
+ term: postprocess(rule.term),
429
+ };
441
430
  case "pnotp":
442
- return { kind: "pnotp", positive: pp(rule.positive), negative: pp(rule.negative) };
431
+ return {
432
+ kind: "pnotp",
433
+ positive: postprocess(rule.positive),
434
+ negative: postprocess(rule.negative),
435
+ };
443
436
  case "congruencelr":
444
437
  case "congruencerl":
445
438
  return {
446
439
  kind: rule.kind,
447
- context: pp(rule.context),
448
- left: pp(rule.left),
449
- right: pp(rule.right),
440
+ context: postprocess(rule.context),
441
+ left: postprocess(rule.left),
442
+ right: postprocess(rule.right),
450
443
  };
451
444
  case "definition":
452
445
  return {
453
446
  kind: "definition",
454
447
  name: rule.name,
455
- folded: pp(rule.folded),
456
- unfolded: pp(rule.unfolded),
448
+ folded: postprocess(rule.folded),
449
+ unfolded: postprocess(rule.unfolded),
457
450
  };
458
451
  case "extension":
459
452
  return {
460
453
  kind: "extension",
461
454
  name: rule.name,
462
- args: rule.args.map(pp),
463
- conclusions: rule.conclusions.map(pp),
464
- branches: rule.branches.map((branch) => branch.map(pp)),
455
+ args: rule.args.map(postprocess),
456
+ conclusions: rule.conclusions.map(postprocess),
457
+ branches: rule.branches.map((branch) => branch.map(postprocess)),
465
458
  };
466
459
  case "lemma":
467
- return { kind: "lemma", name: rule.name, args: rule.args.map(pp) };
460
+ return { kind: "lemma", name: rule.name, args: rule.args.map(postprocess) };
468
461
  }
469
462
  };
470
- const ppTree = (tree: LlProof): LlProof => ({
471
- conclusions: tree.conclusions.map(pp),
472
- rule: ppRule(tree.rule),
473
- subproofs: tree.subproofs.map(ppTree),
463
+ const postprocessTree = (tree: LlProof): LlProof => ({
464
+ conclusions: tree.conclusions.map(postprocess),
465
+ rule: postprocessRule(tree.rule),
466
+ subproofs: tree.subproofs.map(postprocessTree),
474
467
  });
475
468
  return lemmas.map((lemma) => ({
476
469
  name: lemma.name,
477
- params: lemma.params.map((param): [string, Expr] => [param[0], pp(param[1])]),
478
- proof: ppTree(lemma.proof),
470
+ params: lemma.params.map((param): [string, Expr] => [param[0], postprocess(param[1])]),
471
+ proof: postprocessTree(lemma.proof),
479
472
  }));
480
473
  };