tla-ts 0.0.9 → 0.0.10-dev.b4a856304

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (390) hide show
  1. package/README.md +29 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +28 -28
  5. package/dist/deciders.js +43 -43
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +72 -10
  8. package/dist/index.d.ts +72 -10
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +116 -36
  15. package/dist/prove.js +116 -36
  16. package/dist/run.cjs +143 -31
  17. package/dist/run.js +143 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +128 -103
  21. package/dist/transfer.js +128 -103
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +3 -1
  25. package/src/ast.ts +7 -21
  26. package/src/bags.ts +99 -99
  27. package/src/builtins.ts +44 -75
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check.ts +576 -300
  30. package/src/cli/options.ts +11 -6
  31. package/src/cli/run.ts +2 -2
  32. package/src/cli/runtime-invariants.ts +135 -0
  33. package/src/cli/shared.ts +20 -9
  34. package/src/cli/tlapm.ts +0 -12
  35. package/src/cli/tlc-arguments.ts +646 -0
  36. package/src/cli/tlc-usage.ts +362 -0
  37. package/src/cli/tlc.ts +538 -220
  38. package/src/cli/typescript.ts +23 -0
  39. package/src/cli/xml-exporter.ts +4 -16
  40. package/src/cli.ts +0 -1
  41. package/src/codegen.ts +191 -64
  42. package/src/config.ts +140 -109
  43. package/src/coverage.ts +837 -0
  44. package/src/dependencies.ts +6 -40
  45. package/src/dfid.ts +618 -0
  46. package/src/environment.ts +240 -118
  47. package/src/errors.ts +70 -55
  48. package/src/evaluate.ts +630 -297
  49. package/src/exit-codes.ts +37 -3
  50. package/src/fingerprints.ts +10 -10
  51. package/src/index.ts +3 -0
  52. package/src/instances.ts +79 -11
  53. package/src/java-overrides.ts +2 -12
  54. package/src/json-reader.ts +456 -0
  55. package/src/json.ts +262 -139
  56. package/src/levels.ts +2 -3
  57. package/src/lexer.ts +17 -26
  58. package/src/liveness-checker.ts +10 -18
  59. package/src/liveness.ts +121 -49
  60. package/src/obligations/action.ts +4 -28
  61. package/src/obligations/anonymize.ts +84 -80
  62. package/src/obligations/equality.ts +1 -1
  63. package/src/obligations/expression.ts +2 -19
  64. package/src/obligations/format.ts +1 -9
  65. package/src/obligations/generate.ts +1 -11
  66. package/src/obligations/index.ts +0 -11
  67. package/src/obligations/levels.ts +4 -8
  68. package/src/obligations/module.ts +1 -15
  69. package/src/obligations/normalize.ts +5 -24
  70. package/src/obligations/operators.ts +1 -2
  71. package/src/obligations/pragma.ts +1 -10
  72. package/src/obligations/printer.ts +47 -46
  73. package/src/obligations/proof.ts +1 -5
  74. package/src/obligations/regroup.ts +1 -4
  75. package/src/obligations/simplify.ts +3 -14
  76. package/src/obligations/source.ts +1 -21
  77. package/src/obligations/subexpression.ts +5 -11
  78. package/src/obligations/substitution.ts +1 -3
  79. package/src/obligations/temporal.ts +8 -14
  80. package/src/obligations/tuples.ts +3 -9
  81. package/src/parallel-worker.ts +29 -39
  82. package/src/parallel.ts +29 -13
  83. package/src/parser.ts +436 -90
  84. package/src/pcal/ast.ts +7 -28
  85. package/src/pcal/parse.ts +11 -39
  86. package/src/pcal/tokenize.ts +4 -20
  87. package/src/pcal/translate.ts +10 -42
  88. package/src/pcal/validate.ts +3 -21
  89. package/src/pretty-print.ts +1 -2
  90. package/src/prover/decide-pool.ts +5 -10
  91. package/src/prover/deciders.ts +0 -4
  92. package/src/prover/first-order.ts +0 -11
  93. package/src/prover/isabelle/decide.ts +0 -6
  94. package/src/prover/isabelle/encode.ts +11 -23
  95. package/src/prover/isabelle/isar/inner-syntax.ts +108 -114
  96. package/src/prover/isabelle/isar/method.ts +25 -38
  97. package/src/prover/isabelle/isar/proof.ts +1 -10
  98. package/src/prover/isabelle/isar/statement.ts +1 -6
  99. package/src/prover/isabelle/isar/theory.ts +15 -26
  100. package/src/prover/isabelle/isar/type-check.ts +11 -25
  101. package/src/prover/isabelle/provers/blast/blast.ts +10 -41
  102. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  103. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  104. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  105. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  106. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  107. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  108. package/src/prover/isabelle/provers/classical.ts +14 -42
  109. package/src/prover/isabelle/provers/hypsubst.ts +11 -25
  110. package/src/prover/isabelle/pure/bicompose.ts +16 -13
  111. package/src/prover/isabelle/pure/consts.ts +1 -7
  112. package/src/prover/isabelle/pure/conv.ts +1 -9
  113. package/src/prover/isabelle/pure/drule.ts +24 -40
  114. package/src/prover/isabelle/pure/envir.ts +3 -52
  115. package/src/prover/isabelle/pure/goal.ts +1 -7
  116. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  117. package/src/prover/isabelle/pure/list.ts +0 -3
  118. package/src/prover/isabelle/pure/logic.ts +1 -14
  119. package/src/prover/isabelle/pure/name.ts +2 -9
  120. package/src/prover/isabelle/pure/net.ts +3 -59
  121. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  122. package/src/prover/isabelle/pure/pattern.ts +2 -19
  123. package/src/prover/isabelle/pure/raw-simplifier.ts +13 -49
  124. package/src/prover/isabelle/pure/rewriter.ts +26 -58
  125. package/src/prover/isabelle/pure/search.ts +3 -10
  126. package/src/prover/isabelle/pure/seq.ts +1 -10
  127. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  128. package/src/prover/isabelle/pure/table.ts +1 -31
  129. package/src/prover/isabelle/pure/tactic.ts +12 -22
  130. package/src/prover/isabelle/pure/tactical.ts +6 -12
  131. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  132. package/src/prover/isabelle/pure/term.ts +2 -43
  133. package/src/prover/isabelle/pure/thm.ts +13 -36
  134. package/src/prover/isabelle/pure/type.ts +2 -15
  135. package/src/prover/isabelle/pure/unify.ts +20 -30
  136. package/src/prover/isabelle/pure/variable.ts +3 -7
  137. package/src/prover/isabelle/tla/classical-setup.ts +9 -19
  138. package/src/prover/isabelle/tla/context.ts +8 -16
  139. package/src/prover/isabelle/tla/logic.ts +4 -11
  140. package/src/prover/isabelle/tla/simpdata.ts +46 -34
  141. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  142. package/src/prover/ocaml.ts +0 -6
  143. package/src/prover/prep/action.ts +4 -36
  144. package/src/prover/prep/enabled-axioms.ts +12 -19
  145. package/src/prover/prep/fingerprint.ts +0 -16
  146. package/src/prover/prep/level-comparison.ts +8 -12
  147. package/src/prover/prep/md5.ts +0 -2
  148. package/src/prover/prep/methods.ts +9 -36
  149. package/src/prover/prep/normalize.ts +4 -28
  150. package/src/prover/prove-worker.ts +0 -2
  151. package/src/prover/prove.ts +0 -36
  152. package/src/prover/ptl/decide.ts +7 -12
  153. package/src/prover/ptl/encode.ts +14 -36
  154. package/src/prover/ptl/sat.ts +24 -32
  155. package/src/prover/ptl/tableau.ts +12 -26
  156. package/src/prover/smt/axioms.ts +0 -7
  157. package/src/prover/smt/context.ts +19 -26
  158. package/src/prover/smt/data.ts +51 -54
  159. package/src/prover/smt/encode.ts +14 -35
  160. package/src/prover/smt/extensionality.ts +0 -10
  161. package/src/prover/smt/flatten.ts +3 -22
  162. package/src/prover/smt/format.ts +5 -10
  163. package/src/prover/smt/instances.ts +0 -10
  164. package/src/prover/smt/rewrite.ts +66 -101
  165. package/src/prover/smt/solver/act-cache.ts +0 -15
  166. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  167. package/src/prover/smt/solver/array.ts +1 -3
  168. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  169. package/src/prover/smt/solver/ast-lt.ts +1 -11
  170. package/src/prover/smt/solver/ast-util.ts +1 -6
  171. package/src/prover/smt/solver/ast.ts +1 -143
  172. package/src/prover/smt/solver/auf-solver.ts +6 -39
  173. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  174. package/src/prover/smt/solver/cg-table.ts +1 -18
  175. package/src/prover/smt/solver/clause.ts +1 -27
  176. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  177. package/src/prover/smt/solver/context.ts +4 -61
  178. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  179. package/src/prover/smt/solver/der.ts +2 -21
  180. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  181. package/src/prover/smt/solver/e-matching.ts +3 -34
  182. package/src/prover/smt/solver/enode.ts +1 -21
  183. package/src/prover/smt/solver/expr-ref.ts +1 -5
  184. package/src/prover/smt/solver/expr-safe-replace.ts +0 -5
  185. package/src/prover/smt/solver/fingerprints.ts +1 -12
  186. package/src/prover/smt/solver/flat-literals.ts +1 -9
  187. package/src/prover/smt/solver/goal.ts +2 -14
  188. package/src/prover/smt/solver/hash.ts +0 -8
  189. package/src/prover/smt/solver/hashtable.ts +1 -12
  190. package/src/prover/smt/solver/internalizer.ts +6 -98
  191. package/src/prover/smt/solver/lbool.ts +1 -2
  192. package/src/prover/smt/solver/literal.ts +0 -3
  193. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  194. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  195. package/src/prover/smt/solver/lp/containers.ts +12 -30
  196. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  197. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  198. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  199. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  200. package/src/prover/smt/solver/lp/dioph-eq.ts +12 -98
  201. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  202. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  203. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  204. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  205. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  206. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  207. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  208. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  209. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  210. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  211. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  212. package/src/prover/smt/solver/lp/nex.ts +1 -6
  213. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  214. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  215. package/src/prover/smt/solver/lp/nla-core.ts +35 -130
  216. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  217. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  218. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  220. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  221. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  222. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  223. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  224. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  225. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  226. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  227. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  228. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  229. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  230. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  231. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  232. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  233. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  234. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  235. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  236. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  237. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  238. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  239. package/src/prover/smt/solver/mam-compiler.ts +14 -56
  240. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  241. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  242. package/src/prover/smt/solver/model-checker.ts +2 -36
  243. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  244. package/src/prover/smt/solver/model-finder.ts +3 -15
  245. package/src/prover/smt/solver/model-generator.ts +1 -12
  246. package/src/prover/smt/solver/model-macro-solver.ts +12 -69
  247. package/src/prover/smt/solver/nlsat/algebraic.ts +55 -151
  248. package/src/prover/smt/solver/nlsat/atoms.ts +5 -19
  249. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  250. package/src/prover/smt/solver/nlsat/explain.ts +3 -47
  251. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  252. package/src/prover/smt/solver/nlsat/levelwise.ts +48 -129
  253. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  254. package/src/prover/smt/solver/nlsat/polynomial.ts +17 -156
  255. package/src/prover/smt/solver/nlsat/solver.ts +7 -67
  256. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  257. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -44
  258. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  259. package/src/prover/smt/solver/nnf.ts +3 -38
  260. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  261. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  262. package/src/prover/smt/solver/propagate-values.ts +1 -10
  263. package/src/prover/smt/solver/proto-model.ts +3 -48
  264. package/src/prover/smt/solver/pull-quant.ts +1 -12
  265. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  266. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  267. package/src/prover/smt/solver/qe-lite.ts +3 -33
  268. package/src/prover/smt/solver/qi-queue.ts +1 -16
  269. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  270. package/src/prover/smt/solver/quantifier-analyzer.ts +17 -37
  271. package/src/prover/smt/solver/quantifier-manager.ts +1 -8
  272. package/src/prover/smt/solver/random-gen.ts +1 -2
  273. package/src/prover/smt/solver/rational.ts +1 -8
  274. package/src/prover/smt/solver/ref-vector.ts +1 -6
  275. package/src/prover/smt/solver/relevancy.ts +2 -15
  276. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  277. package/src/prover/smt/solver/rewriter.ts +3 -85
  278. package/src/prover/smt/solver/rlimit.ts +2 -20
  279. package/src/prover/smt/solver/smtlib-parser.ts +2 -37
  280. package/src/prover/smt/solver/solver.ts +23 -34
  281. package/src/prover/smt/solver/sort.ts +1 -5
  282. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  283. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  284. package/src/prover/smt/solver/theory-lra-bounds.ts +0 -5
  285. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  286. package/src/prover/smt/solver/theory-lra-internalize.ts +1 -27
  287. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  288. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  289. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  290. package/src/prover/smt/solver/theory-lra.ts +1 -8
  291. package/src/prover/smt/solver/var-subst.ts +2 -26
  292. package/src/prover/smt/table.ts +0 -8
  293. package/src/prover/tlapm/cache.ts +20 -25
  294. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  295. package/src/prover/tlapm/tlapm.ts +12 -17
  296. package/src/prover/verdict.ts +0 -2
  297. package/src/prover/zenon/check/check.ts +0 -9
  298. package/src/prover/zenon/check/definitions.ts +5 -15
  299. package/src/prover/zenon/check/equality.ts +0 -8
  300. package/src/prover/zenon/check/functions.ts +0 -4
  301. package/src/prover/zenon/check/keys.ts +0 -7
  302. package/src/prover/zenon/check/propositional.ts +0 -3
  303. package/src/prover/zenon/check/records.ts +0 -5
  304. package/src/prover/zenon/check/relations.ts +0 -13
  305. package/src/prover/zenon/check/rewrites.ts +0 -6
  306. package/src/prover/zenon/check/sets.ts +0 -3
  307. package/src/prover/zenon/check/terms.ts +0 -17
  308. package/src/prover/zenon/check/tla.ts +0 -6
  309. package/src/prover/zenon/decide.ts +0 -12
  310. package/src/prover/zenon/encode.ts +1 -8
  311. package/src/prover/zenon/eqrel.ts +0 -13
  312. package/src/prover/zenon/equality-rules.ts +0 -4
  313. package/src/prover/zenon/expr.ts +1 -26
  314. package/src/prover/zenon/index-table.ts +17 -38
  315. package/src/prover/zenon/isar-case.ts +9 -19
  316. package/src/prover/zenon/isar.ts +1 -29
  317. package/src/prover/zenon/limits.ts +0 -4
  318. package/src/prover/zenon/llproof.ts +0 -9
  319. package/src/prover/zenon/mltoll.ts +54 -76
  320. package/src/prover/zenon/node.ts +1 -11
  321. package/src/prover/zenon/ocaml.ts +1 -17
  322. package/src/prover/zenon/parse.ts +2 -7
  323. package/src/prover/zenon/phrase.ts +1 -11
  324. package/src/prover/zenon/proof.ts +0 -9
  325. package/src/prover/zenon/propositional-rules.ts +0 -5
  326. package/src/prover/zenon/rules.ts +2 -6
  327. package/src/prover/zenon/search.ts +1 -17
  328. package/src/prover/zenon/tla/functions.ts +57 -29
  329. package/src/prover/zenon/tla/llproof.ts +63 -70
  330. package/src/prover/zenon/tla/records.ts +56 -27
  331. package/src/prover/zenon/tla/rewrites.ts +12 -19
  332. package/src/prover/zenon/tla/sets.ts +68 -39
  333. package/src/prover/zenon/tla/terms.ts +0 -6
  334. package/src/prover/zenon/tla/tla.ts +59 -58
  335. package/src/randomization.ts +84 -35
  336. package/src/resolve.ts +18 -60
  337. package/src/runtime.ts +11 -4
  338. package/src/sany/builtins.ts +3 -4
  339. package/src/sany/generator.ts +119 -169
  340. package/src/sany/levels.ts +6 -30
  341. package/src/sany/lexer.ts +7 -23
  342. package/src/sany/linter.ts +1 -8
  343. package/src/sany/modules.ts +1 -5
  344. package/src/sany/nodes.ts +0 -31
  345. package/src/sany/parse-error.ts +39 -117
  346. package/src/sany/report.ts +29 -63
  347. package/src/sany/selectors.ts +15 -39
  348. package/src/sany/source.ts +1 -17
  349. package/src/sany/xml.ts +13 -63
  350. package/src/search.ts +494 -154
  351. package/src/simulate.ts +694 -0
  352. package/src/spec-description.ts +166 -48
  353. package/src/standard-definitions.ts +2 -3
  354. package/src/standard-modules.ts +264 -68
  355. package/src/state-graph.ts +51 -18
  356. package/src/subexpressions.ts +31 -5
  357. package/src/substitution-levels.ts +2 -3
  358. package/src/successors.ts +267 -77
  359. package/src/symmetry.ts +31 -8
  360. package/src/tableau.ts +27 -24
  361. package/src/tlc/fingerprint.ts +183 -61
  362. package/src/tlc/jar-data.ts +113 -6
  363. package/src/tlc/messages.ts +122 -37
  364. package/src/tlc/order.ts +33 -38
  365. package/src/tlc/random.ts +16 -16
  366. package/src/tlc/replay.ts +563 -211
  367. package/src/tlc/summary.ts +2 -4
  368. package/src/tlc/tlc-operators.ts +81 -36
  369. package/src/tlc/tlcext-operators.ts +138 -117
  370. package/src/tlc/trace-spec.ts +273 -0
  371. package/src/tlc/value-stream.ts +143 -0
  372. package/src/tlc/version.ts +2 -4
  373. package/src/transfer.ts +22 -25
  374. package/src/typescript/actions.ts +481 -0
  375. package/src/typescript/collections.ts +600 -0
  376. package/src/typescript/compile.ts +65 -0
  377. package/src/typescript/context.ts +94 -0
  378. package/src/typescript/emit.ts +121 -0
  379. package/src/typescript/expressions.ts +496 -0
  380. package/src/typescript/formula.ts +152 -0
  381. package/src/typescript/functions.ts +284 -0
  382. package/src/typescript/model.ts +163 -0
  383. package/src/typescript/names.ts +114 -0
  384. package/src/typescript/program.ts +48 -0
  385. package/src/typescript/properties.ts +139 -0
  386. package/src/typescript/scope.ts +112 -0
  387. package/src/typescript/steps.ts +165 -0
  388. package/src/typescript/types.ts +171 -0
  389. package/src/values.ts +826 -276
  390. package/src/worker.ts +7 -8
@@ -1,5 +1,4 @@
1
- // A port of tlapm's anonymization (Expr.Anon, Elab.desugar and Proof.Anon): names become de Bruijn
2
- // indices into the context, builtin definitions are inlined, and anonymous steps get names.
1
+ // A port of tlapm's anonymization (Expr.Anon, Elab.desugar and Proof.Anon).
3
2
 
4
3
  import { TlapmBugError, TlaProofError } from "../errors";
5
4
  import { consSubstitution, normalizeApply, shift, shiftExpr, substituteExpr } from "./substitution";
@@ -65,7 +64,6 @@ const ANON_SELECTOR_FAILURES = {
65
64
 
66
65
  const BAD_EXPRESSION: Expr = { kind: "Opaque", name: "$badexp" };
67
66
 
68
- // Util.set_locus: the node keeps its properties and takes the location of from.
69
67
  const withLocus = (expression: Expr, from: Expr) =>
70
68
  from.location ? { ...expression, location: from.location } : expression;
71
69
 
@@ -82,20 +80,19 @@ export const createAnonymizer = (
82
80
  ) => Defn[],
83
81
  onWarning: Warn,
84
82
  ) => {
85
- // Elab.desugar's current_at: the value @ stands for inside an EXCEPT, and the context size there.
86
83
  let currentAt: { expression: Expr; size: number } | undefined;
87
84
 
88
85
  const getContext = (scope: Scope | undefined): AnonContext => ({ warnedSteps: [], scope });
89
86
 
90
87
  const getSize = (context: AnonContext) => context.scope?.size ?? 0;
91
88
 
92
- const expr = (context: AnonContext, expression: Expr): Expr => {
89
+ const anonymizeExpr = (context: AnonContext, expression: Expr): Expr => {
93
90
  if (expression.kind === "At" && expression.isExcept) {
94
91
  if (!currentAt) return expression;
95
92
  return shiftExpr(getSize(context) - currentAt.size, currentAt.expression);
96
93
  }
97
- if (expression.kind !== "Except") return anonCore(context, expression);
98
- const base = expr(context, expression.function);
94
+ if (expression.kind !== "Except") return anonymizeCore(context, expression);
95
+ const base = anonymizeExpr(context, expression.function);
99
96
  return expression.specs.reduce((result, spec) => {
100
97
  const [path, trail] = mapAccumulate(
101
98
  result,
@@ -104,7 +101,7 @@ export const createAnonymizer = (
104
101
  if (point.kind === "Dot") {
105
102
  return [at({ kind: "Dot", expression: current, field: point.field }, current), point];
106
103
  }
107
- const key = expr(context, point.expression);
104
+ const key = anonymizeExpr(context, point.expression);
108
105
  return [
109
106
  at({ kind: "FcnApp", function: current, args: [key] }, current),
110
107
  { kind: "Apply", expression: key },
@@ -113,25 +110,25 @@ export const createAnonymizer = (
113
110
  );
114
111
  const saved = currentAt;
115
112
  currentAt = { expression: path, size: getSize(context) };
116
- const value = expr(context, spec.value);
113
+ const value = anonymizeExpr(context, spec.value);
117
114
  currentAt = saved;
118
115
  return at({ kind: "Except", function: result, specs: [{ trail, value }] }, expression);
119
116
  }, base);
120
117
  };
121
118
 
122
- const anonApply = (index: number, args: Expr[], from: Expr): Expr => {
119
+ const createAnonApply = (index: number, args: Expr[], from: Expr): Expr => {
123
120
  const indexed = at({ kind: "Ix", index }, from);
124
121
  return args.length === 0 ? indexed : at({ kind: "Apply", operator: indexed, args }, from);
125
122
  };
126
123
 
127
- const standardForm = (
124
+ const createStandardForm = (
128
125
  index: number,
129
126
  whereDefined: WhereDefined,
130
127
  body: Expr,
131
128
  args: Expr[],
132
129
  from: Expr,
133
130
  ): Expr => {
134
- if (whereDefined !== "Builtin") return anonApply(index, args, from);
131
+ if (whereDefined !== "Builtin") return createAnonApply(index, args, from);
135
132
  const shifted = shiftExpr(index, body);
136
133
  return at(args.length === 0 ? shifted : normalizeApply(shifted, args), from);
137
134
  };
@@ -149,16 +146,16 @@ export const createAnonymizer = (
149
146
  case "Defn": {
150
147
  const definition = hyp.definition;
151
148
  if (definition.kind === "Operator") {
152
- return standardForm(index, hyp.whereDefined, definition.body, args, from);
149
+ return createStandardForm(index, hyp.whereDefined, definition.body, args, from);
153
150
  }
154
151
  if (definition.kind === "Recursive")
155
152
  throw new TlaProofError("Recursive operators not supported by TLAPS", {
156
153
  failure: "Expr.Anon: Recursive",
157
154
  });
158
- return anonApply(index, args, from);
155
+ return createAnonApply(index, args, from);
159
156
  }
160
157
  case "Fresh":
161
- return anonApply(index, args, from);
158
+ return createAnonApply(index, args, from);
162
159
  case "Flex":
163
160
  return at({ kind: "Ix", index }, from);
164
161
  case "Fact":
@@ -168,7 +165,6 @@ export const createAnonymizer = (
168
165
  }
169
166
  };
170
167
 
171
- // Expr.Anon's check: a prefix that names nothing joins the next label, as in an instance path.
172
168
  const resolveBang = (
173
169
  context: AnonContext,
174
170
  prefix: string,
@@ -181,7 +177,7 @@ export const createAnonymizer = (
181
177
  if (!found) {
182
178
  const [selector, ...rest] = selectors;
183
179
  if (selector?.kind === "Label") {
184
- const labelArgs = selector.args.map((arg) => expr(context, arg));
180
+ const labelArgs = selector.args.map((arg) => anonymizeExpr(context, arg));
185
181
  return resolveBang(
186
182
  context,
187
183
  `${prefix}!${selector.label}`,
@@ -208,25 +204,25 @@ export const createAnonymizer = (
208
204
  if (selectors.length === 0 && isInstance) {
209
205
  return args.length === 0
210
206
  ? at({ kind: "Ix", index }, from)
211
- : standardForm(index, hyp.whereDefined, hyp.definition.body, args, from);
207
+ : createStandardForm(index, hyp.whereDefined, hyp.definition.body, args, from);
212
208
  }
213
209
  const body = withLocus(shiftExpr(index, hyp.definition.body), from);
214
210
  return withLocus(resolveSubexpression(onWarning, body, args, selectors), from);
215
211
  };
216
212
 
217
- const anonCore = (context: AnonContext, expression: Expr): Expr => {
213
+ const anonymizeCore = (context: AnonContext, expression: Expr): Expr => {
218
214
  switch (expression.kind) {
219
215
  case "Bang": {
220
216
  const inner = expression.expression;
221
217
  if (inner.kind === "Apply" && inner.operator.kind === "Opaque") {
222
218
  const selectors = expression.selectors.map((selector) =>
223
- mapSelectorArgs(selector, (arg) => expr(context, arg)),
219
+ mapSelectorArgs(selector, (arg) => anonymizeExpr(context, arg)),
224
220
  );
225
- const args = inner.args.map((arg) => expr(context, arg));
221
+ const args = inner.args.map((arg) => anonymizeExpr(context, arg));
226
222
  const bangContext = getContext(context.scope);
227
223
  return resolveBang(bangContext, inner.operator.name, args, selectors, false, expression);
228
224
  }
229
- return expr(context, {
225
+ return anonymizeExpr(context, {
230
226
  ...expression,
231
227
  expression: at({ kind: "Apply", operator: inner, args: [] }, inner),
232
228
  });
@@ -241,24 +237,27 @@ export const createAnonymizer = (
241
237
  });
242
238
  return at({ kind: "Internal", builtin: "TRUE" }, expression);
243
239
  }
244
- const args = expression.args.map((arg) => expr(context, arg));
240
+ const args = expression.args.map((arg) => anonymizeExpr(context, arg));
245
241
  return resolveName(context, name, args, expression);
246
242
  }
247
243
  case "Opaque":
248
- return expr(context, at({ kind: "Apply", operator: expression, args: [] }, expression));
244
+ return anonymizeExpr(
245
+ context,
246
+ at({ kind: "Apply", operator: expression, args: [] }, expression),
247
+ );
249
248
  case "Parens":
250
- if (expression.form.kind === "Syntax") return expr(context, expression.expression);
249
+ if (expression.form.kind === "Syntax") return anonymizeExpr(context, expression.expression);
251
250
  return {
252
251
  ...expression,
253
- expression: expr(context, expression.expression),
254
- form: anonParenForm(context, expression.form),
252
+ expression: anonymizeExpr(context, expression.expression),
253
+ form: anonymizeParenForm(context, expression.form),
255
254
  };
256
255
  default:
257
256
  return visit(context, expression);
258
257
  }
259
258
  };
260
259
 
261
- const anonParenForm = (context: AnonContext, form: ParenForm): ParenForm => {
260
+ const anonymizeParenForm = (context: AnonContext, form: ParenForm): ParenForm => {
262
261
  if (form.kind !== "Nlabel") return form;
263
262
  return {
264
263
  kind: "Xlabel",
@@ -282,29 +281,30 @@ export const createAnonymizer = (
282
281
  const adjoinBounds = (context: AnonContext, items: Bound[]) =>
283
282
  withScope(context, adjoinAll(context.scope, items.map(getBoundFresh)));
284
283
 
285
- const bounds = (context: AnonContext, items: Bound[]): [AnonContext, Bound[]] => {
286
- const mapped = mapBoundDomains(items, (domain) => expr(context, domain));
284
+ const anonymizeBounds = (context: AnonContext, items: Bound[]): [AnonContext, Bound[]] => {
285
+ const mapped = mapBoundDomains(items, (domain) => anonymizeExpr(context, domain));
287
286
  return [adjoinBounds(context, mapped), mapped];
288
287
  };
289
288
 
290
- // Visit.map, apart from the definitions an ASSUME or a LET binds.
291
289
  const visit = (context: AnonContext, expression: Expr): Expr => {
292
290
  if (expression.kind === "Sequent") {
293
- return { ...expression, sequent: sequent(context, expression.sequent)[1] };
291
+ return { ...expression, sequent: anonymizeSequent(context, expression.sequent)[1] };
294
292
  }
295
293
  if (expression.kind === "Let") {
296
- const [inner, definitions] = defns(context, expression.definitions);
297
- return { ...expression, definitions, body: expr(inner, expression.body) };
294
+ const [inner, definitions] = anonymizeDefns(context, expression.definitions);
295
+ return { ...expression, definitions, body: anonymizeExpr(inner, expression.body) };
298
296
  }
299
- return mapScoped(context, expression, expr, adjoinContext);
297
+ return mapScoped(context, expression, anonymizeExpr, adjoinContext);
300
298
  };
301
299
 
302
- // Expr.Anon's defn turns a recursive function definition into a CHOOSE over its own equation.
303
- const defn = (context: AnonContext, definition: Defn): Defn => {
300
+ const anonymizeDefn = (context: AnonContext, definition: Defn): Defn => {
304
301
  if (definition.kind !== "Operator") return definition;
305
302
  const body = definition.body;
306
- if (body.kind !== "Fcn") return { ...definition, body: expr(context, body) };
307
- const inner = expr(adjoinContext(context, getFresh(definition.name, "Constant")), body);
303
+ if (body.kind !== "Fcn") return { ...definition, body: anonymizeExpr(context, body) };
304
+ const inner = anonymizeExpr(
305
+ adjoinContext(context, getFresh(definition.name, "Constant")),
306
+ body,
307
+ );
308
308
  const marker: Expr = { kind: "Opaque", name: "%%%" };
309
309
  const isRecursive = !isEqualExpr(
310
310
  substituteExpr(consSubstitution(marker, shift(1)), inner),
@@ -318,8 +318,7 @@ export const createAnonymizer = (
318
318
  };
319
319
  };
320
320
 
321
- // Module.Elab.anon#defns: an INSTANCE stands for the definitions it instantiates.
322
- const defns = (context: AnonContext, definitions: Defn[]): [AnonContext, Defn[]] => {
321
+ const anonymizeDefns = (context: AnonContext, definitions: Defn[]): [AnonContext, Defn[]] => {
323
322
  let current = context;
324
323
  const queue = [...definitions];
325
324
  const mapped: Defn[] = [];
@@ -329,24 +328,24 @@ export const createAnonymizer = (
329
328
  queue.splice(index + 1, 0, ...expandInstance(current.scope, definition));
330
329
  continue;
331
330
  }
332
- const result = defn(current, definition);
331
+ const result = anonymizeDefn(current, definition);
333
332
  current = adjoinContext(current, { ...getLocalDefn(result), isConstnessUnset: true });
334
333
  mapped.push(result);
335
334
  }
336
335
  return [current, mapped];
337
336
  };
338
337
 
339
- const hyp = (context: AnonContext, item: Hyp): [AnonContext, Hyp] => {
338
+ const anonymizeHyp = (context: AnonContext, item: Hyp): [AnonContext, Hyp] => {
340
339
  const mapped = ((): Hyp => {
341
340
  switch (item.kind) {
342
341
  case "Fresh":
343
- return item.domain ? { ...item, domain: expr(context, item.domain) } : item;
342
+ return item.domain ? { ...item, domain: anonymizeExpr(context, item.domain) } : item;
344
343
  case "Flex":
345
344
  return item;
346
345
  case "Defn":
347
- return { ...item, definition: defn(context, item.definition) };
346
+ return { ...item, definition: anonymizeDefn(context, item.definition) };
348
347
  case "Fact": {
349
- const expression = expr(context, item.expression);
348
+ const expression = anonymizeExpr(context, item.expression);
350
349
  return { ...item, expression, time: getTime(context.scope, expression) };
351
350
  }
352
351
  }
@@ -354,9 +353,9 @@ export const createAnonymizer = (
354
353
  return [adjoinContext(context, mapped), mapped];
355
354
  };
356
355
 
357
- const sequent = (context: AnonContext, item: Sequent): [AnonContext, Sequent] => {
358
- const [inner, hyps] = mapAccumulate(context, item.context, hyp);
359
- return [inner, { context: hyps, active: expr(inner, item.active) }];
356
+ const anonymizeSequent = (context: AnonContext, item: Sequent): [AnonContext, Sequent] => {
357
+ const [inner, hyps] = mapAccumulate(context, item.context, anonymizeHyp);
358
+ return [inner, { context: hyps, active: anonymizeExpr(inner, item.active) }];
360
359
  };
361
360
 
362
361
  const pushWarnedStep = (context: AnonContext, step: StepNumber): AnonContext => ({
@@ -384,7 +383,7 @@ export const createAnonymizer = (
384
383
  ),
385
384
  );
386
385
 
387
- const tupleForm = (item: Sequent): ExprCore => {
386
+ const getTupleForm = (item: Sequent): ExprCore => {
388
387
  const facts = item.context.map((entry, index) => {
389
388
  const amount = item.context.length - index + 1;
390
389
  if (entry.kind === "Fact") return shiftExpr(amount, entry.expression);
@@ -403,11 +402,11 @@ export const createAnonymizer = (
403
402
  const isCitable = (step: Step) =>
404
403
  step.kind !== "Use" && step.kind !== "Hide" && step.kind !== "Define";
405
404
 
406
- const usable = (context: AnonContext, item: Usable): Usable => ({
407
- facts: item.facts.map((fact) => expr(context, fact)),
405
+ const anonymizeUsable = (context: AnonContext, item: Usable): Usable => ({
406
+ facts: item.facts.map((fact) => anonymizeExpr(context, fact)),
408
407
  defs: item.defs.flatMap((def): UseDef[] => {
409
408
  if (def.kind === "Dx") return [def];
410
- const resolved = expr(context, at({ kind: "Opaque", name: def.name }, def));
409
+ const resolved = anonymizeExpr(context, at({ kind: "Opaque", name: def.name }, def));
411
410
  if (resolved.kind !== "Ix") {
412
411
  onWarning({
413
412
  text: `${getLocusPrefix(def.location)}Ignored unexpandable identifier ${JSON.stringify(def.name)} in BY DEF.`,
@@ -426,24 +425,24 @@ export const createAnonymizer = (
426
425
  }),
427
426
  });
428
427
 
429
- const proof = (context: AnonContext, item: Proof): Proof => {
428
+ const anonymizeProof = (context: AnonContext, item: Proof): Proof => {
430
429
  switch (item.kind) {
431
430
  case "Steps": {
432
- const [inner, steps] = mapAccumulate(context, item.steps, step);
433
- const qedProof = proof(
431
+ const [inner, steps] = mapAccumulate(context, item.steps, anonymizeStep);
432
+ const qedProof = anonymizeProof(
434
433
  item.step ? pushWarnedStep(inner, item.step) : inner,
435
434
  item.qed.proof,
436
435
  );
437
436
  return { ...item, steps, qed: { ...item.qed, proof: qedProof } };
438
437
  }
439
438
  case "By":
440
- return { ...item, usable: usable(context, item.usable) };
439
+ return { ...item, usable: anonymizeUsable(context, item.usable) };
441
440
  default:
442
441
  return item;
443
442
  }
444
443
  };
445
444
 
446
- const step = (context: AnonContext, original: Step): [AnonContext, Step] => {
445
+ const anonymizeStep = (context: AnonContext, original: Step): [AnonContext, Step] => {
447
446
  const number: StepNumber | undefined =
448
447
  original.step?.kind === "Unnamed" && isCitable(original)
449
448
  ? {
@@ -457,24 +456,24 @@ export const createAnonymizer = (
457
456
  const item: Step = { ...original, step: number };
458
457
  switch (item.kind) {
459
458
  case "Assert": {
460
- const [, mapped] = sequent(context, item.sequent);
459
+ const [, mapped] = anonymizeSequent(context, item.sequent);
461
460
  const assumptions = mapped.context.reduce(adjoinContext, context);
462
461
  const withTuple = bumpContext(
463
- adjoinStep(bumpContext(assumptions, 1), number, at(tupleForm(mapped), item), item),
462
+ adjoinStep(bumpContext(assumptions, 1), number, at(getTupleForm(mapped), item), item),
464
463
  1,
465
464
  );
466
465
  const inner = mapped.context.length === 0 ? pushWarnedStep(withTuple, number) : withTuple;
467
- const result: Step = { ...item, sequent: mapped, proof: proof(inner, item.proof) };
466
+ const result: Step = { ...item, sequent: mapped, proof: anonymizeProof(inner, item.proof) };
468
467
  return [
469
468
  bumpContext(adjoinStep(context, number, at(exprifySequent(mapped), item), item), 1),
470
469
  result,
471
470
  ];
472
471
  }
473
472
  case "Pcase": {
474
- const expression = expr(context, item.expression);
473
+ const expression = anonymizeExpr(context, item.expression);
475
474
  const tuple = at({ kind: "Tuple", elements: [shiftExpr(2, expression)] }, item);
476
475
  const inner = bumpContext(adjoinStep(bumpContext(context, 2), number, tuple, item), 1);
477
- const result: Step = { ...item, expression, proof: proof(inner, item.proof) };
476
+ const result: Step = { ...item, expression, proof: anonymizeProof(inner, item.proof) };
478
477
  const after = adjoinStep(
479
478
  context,
480
479
  number,
@@ -484,19 +483,19 @@ export const createAnonymizer = (
484
483
  return [bumpContext(after, 1), result];
485
484
  }
486
485
  case "Suffices": {
487
- const [, mapped] = sequent(context, item.sequent);
486
+ const [, mapped] = anonymizeSequent(context, item.sequent);
488
487
  const fact = at({ kind: "Tuple", elements: [at(exprifySequent(mapped), item)] }, item);
489
488
  const inner = bumpContext(adjoinStep(context, number, fact, item), 1);
490
- const result: Step = { ...item, sequent: mapped, proof: proof(inner, item.proof) };
489
+ const result: Step = { ...item, sequent: mapped, proof: anonymizeProof(inner, item.proof) };
491
490
  const assumptions = mapped.context.reduce(adjoinContext, context);
492
- const tuple = at({ kind: "Tuple", elements: [at(tupleForm(mapped), item)] }, item);
491
+ const tuple = at({ kind: "Tuple", elements: [at(getTupleForm(mapped), item)] }, item);
493
492
  return [
494
493
  bumpContext(adjoinStep(bumpContext(assumptions, 1), number, tuple, item), 1),
495
494
  result,
496
495
  ];
497
496
  }
498
497
  case "Have": {
499
- const expression = expr(context, item.expression);
498
+ const expression = anonymizeExpr(context, item.expression);
500
499
  const tuple = at({ kind: "Tuple", elements: [shiftExpr(2, expression)] }, item);
501
500
  return [
502
501
  bumpContext(adjoinStep(bumpContext(context, 2), number, tuple, item), 1),
@@ -504,7 +503,7 @@ export const createAnonymizer = (
504
503
  ];
505
504
  }
506
505
  case "Take": {
507
- const [inner, mapped] = bounds(context, item.bounds);
506
+ const [inner, mapped] = anonymizeBounds(context, item.bounds);
508
507
  const universal = at(
509
508
  { kind: "Quant", quantifier: "Forall", bounds: mapped, body: BAD_EXPRESSION },
510
509
  item,
@@ -515,7 +514,9 @@ export const createAnonymizer = (
515
514
  ];
516
515
  }
517
516
  case "Witness": {
518
- const expressions = item.expressions.map((expression) => expr(context, expression));
517
+ const expressions = item.expressions.map((expression) =>
518
+ anonymizeExpr(context, expression),
519
+ );
519
520
  const tuple = at({ kind: "Tuple", elements: expressions }, item);
520
521
  return [
521
522
  bumpContext(adjoinStep(bumpContext(context, 1), number, tuple, item), 1),
@@ -523,8 +524,8 @@ export const createAnonymizer = (
523
524
  ];
524
525
  }
525
526
  case "Pick": {
526
- const [boundContext, mapped] = bounds(context, item.bounds);
527
- const expression = expr(boundContext, item.expression);
527
+ const [boundContext, mapped] = anonymizeBounds(context, item.bounds);
528
+ const expression = anonymizeExpr(boundContext, item.expression);
528
529
  const existential = at(
529
530
  { kind: "Quant", quantifier: "Exists", bounds: mapped, body: expression },
530
531
  item,
@@ -537,7 +538,7 @@ export const createAnonymizer = (
537
538
  ...item,
538
539
  bounds: mapped,
539
540
  expression,
540
- proof: proof(inner, item.proof),
541
+ proof: anonymizeProof(inner, item.proof),
541
542
  };
542
543
  const declared = adjoinBounds(bumpContext(context, 2), mapped);
543
544
  const shifted = shiftExpr(4 + mapped.length, existential);
@@ -547,13 +548,13 @@ export const createAnonymizer = (
547
548
  ];
548
549
  }
549
550
  case "Use": {
550
- const mapped = usable(context, item.usable);
551
+ const mapped = anonymizeUsable(context, item.usable);
551
552
  return [bumpContext(context, mapped.facts.length), { ...item, usable: mapped }];
552
553
  }
553
554
  case "Hide":
554
- return [context, { ...item, usable: usable(context, item.usable) }];
555
+ return [context, { ...item, usable: anonymizeUsable(context, item.usable) }];
555
556
  case "Define": {
556
- const [inner, definitions] = defns(context, item.definitions);
557
+ const [inner, definitions] = anonymizeDefns(context, item.definitions);
557
558
  return [inner, { ...item, definitions }];
558
559
  }
559
560
  case "Forget":
@@ -562,11 +563,14 @@ export const createAnonymizer = (
562
563
  };
563
564
 
564
565
  return {
565
- expr: (scope: Scope | undefined, expression: Expr) => expr(getContext(scope), expression),
566
- defn: (scope: Scope | undefined, definition: Defn) => defn(getContext(scope), definition),
567
- sequent: (scope: Scope | undefined, item: Sequent) => sequent(getContext(scope), item)[1],
568
- usable: (scope: Scope | undefined, item: Usable) => usable(getContext(scope), item),
569
- proof: (scope: Scope | undefined, item: Proof) => proof(getContext(scope), item),
566
+ expr: (scope: Scope | undefined, expression: Expr) =>
567
+ anonymizeExpr(getContext(scope), expression),
568
+ defn: (scope: Scope | undefined, definition: Defn) =>
569
+ anonymizeDefn(getContext(scope), definition),
570
+ sequent: (scope: Scope | undefined, item: Sequent) =>
571
+ anonymizeSequent(getContext(scope), item)[1],
572
+ usable: (scope: Scope | undefined, item: Usable) => anonymizeUsable(getContext(scope), item),
573
+ proof: (scope: Scope | undefined, item: Proof) => anonymizeProof(getContext(scope), item),
570
574
  };
571
575
  };
572
576
 
@@ -1,4 +1,4 @@
1
- // tlapm's E_eq: alpha-equivalence of expressions.
1
+ // A port of tlapm's E_eq.
2
2
 
3
3
  import type { Bound, Defn, Expr, Field, Hyp, Selector, Sequent } from "./expression";
4
4
 
@@ -1,4 +1,4 @@
1
- // tlapm's expression IR (E_t) with de Bruijn indices, and the visitors that map over it (Visit).
1
+ // A port of tlapm's expression IR (E_t) and its visitors (Visit).
2
2
 
3
3
  import type { OldMethod, PragmaSetting } from "./pragma";
4
4
 
@@ -158,7 +158,6 @@ export interface Param {
158
158
  location?: Locus;
159
159
  }
160
160
 
161
- // isAtomic is Expr.Deref.atomic: a resolved subexpression reference, which has no subexpressions.
162
161
  interface ExprProps {
163
162
  location?: Locus;
164
163
  isAtomic?: boolean;
@@ -224,10 +223,8 @@ type DefnCore =
224
223
 
225
224
  export type Visibility = "Visible" | "Hidden";
226
225
 
227
- // When a fact holds: at every point of a behavior, or only at the current one.
228
226
  export type Time = "Now" | "Always";
229
227
 
230
- // A step or a DEFINE in a proof keeps the time of the scope it is made in.
231
228
  export type WhereDefined = "Builtin" | "User" | { kind: "Proof"; time: Time };
232
229
 
233
230
  export type Hyp = HypCore & { location?: Locus };
@@ -248,8 +245,6 @@ type HypCore =
248
245
  whereDefined: WhereDefined;
249
246
  visibility: Visibility;
250
247
  isLocal: boolean;
251
- // Module.Elab judges whether each module definition is constant. One that anonymization meets
252
- // in a proof, such as a step or a DEFINE, has no judgment, so tlapm never counts it constant.
253
248
  isConstnessUnset?: boolean;
254
249
  }
255
250
  | { kind: "Fact"; expression: Expr; visibility: Visibility; time: Time; useLocation?: Locus };
@@ -259,7 +254,6 @@ export interface Sequent {
259
254
  active: Expr;
260
255
  }
261
256
 
262
- // tlapm's core @@ from, which takes the properties of from.
263
257
  export const at = (core: ExprCore, from: ExprProps): Expr => {
264
258
  const located = from.location ? { ...core, location: from.location } : core;
265
259
  return from.isAtomic ? { ...located, isAtomic: true } : located;
@@ -291,7 +285,6 @@ export const applyBuiltin = (builtin: Builtin, args: Expr[], from: ExprProps): E
291
285
  export const exprifySequent = (sequent: Sequent): ExprCore =>
292
286
  sequent.context.length === 0 ? sequent.active : { kind: "Sequent", sequent };
293
287
 
294
- // A persistent context, newest hypothesis first, so binders extend it without copying.
295
288
  export interface Scope {
296
289
  hyp: Hyp;
297
290
  rest: Scope | undefined;
@@ -342,7 +335,6 @@ export const mapAccumulate = <State, Item, Result>(
342
335
  return [final, results];
343
336
  };
344
337
 
345
- // A mapped context prefix: the hypothesis its last key maps to, if any, and the state after it.
346
338
  interface MappedPrefix<State> {
347
339
  state: State;
348
340
  hyp: Hyp | undefined;
@@ -350,9 +342,6 @@ interface MappedPrefix<State> {
350
342
  next: WeakMap<Hyp, MappedPrefix<State>>;
351
343
  }
352
344
 
353
- // mapAccumulate over a context that maps each prefix of keys once, as the obligations of a module
354
- // share most of their context by identity. The input at each position must depend on the keys up
355
- // to it alone, and the step on the input, its key, and the state.
356
345
  export const createContextMap = <State>(
357
346
  initial: State,
358
347
  step: (state: State, input: Hyp, key: Hyp) => [State, Hyp | undefined],
@@ -405,8 +394,6 @@ export const getFact = (
405
394
  location: Locus | undefined,
406
395
  ) => ({ kind: "Fact", expression, visibility, time, location }) satisfies Hyp;
407
396
 
408
- // What a quantifier binds each name as, a LAMBDA each parameter, and a LET each definition, as
409
- // Visit.map does.
410
397
  export const getBoundFresh = (bound: Bound) => getFresh(bound.name, bound.level);
411
398
 
412
399
  export const getParamFresh = (param: Param) => getFresh(param.name, "Unknown", param.shape);
@@ -420,7 +407,6 @@ export const getLocalDefn = (definition: Defn) =>
420
407
  isLocal: true,
421
408
  }) satisfies Hyp;
422
409
 
423
- // The node without its properties, as tlapm's e.core.
424
410
  export const stripProps = (expression: Expr): ExprCore => {
425
411
  if (!expression.location && !expression.isAtomic) return expression;
426
412
  const { location: _location, isAtomic: _isAtomic, ...core } = expression;
@@ -460,9 +446,7 @@ export const mapHyp = (hyp: Hyp, map: (inner: Expr) => Expr, hyps: "visible" | "
460
446
  return { ...hyp, expression: map(hyp.expression) };
461
447
  };
462
448
 
463
- // Visit.map, threading a state through each binder: a scope or a substitution. Visit.map_visible_hyp
464
- // binds hidden hypotheses without visiting them, and Visit.map visits them too. Children map in
465
- // OCaml evaluation order, last constructor argument first, which decides the error tlapm reports.
449
+ // Children map in OCaml's order, last argument first, which decides the error tlapm reports.
466
450
  export const mapScoped = <State>(
467
451
  state: State,
468
452
  expression: Expr,
@@ -598,7 +582,6 @@ export const mapScoped = <State>(
598
582
  }
599
583
  };
600
584
 
601
- // Visit.map without a state: every child, the hidden hypotheses of an ASSUME included.
602
585
  export const mapChildren = (expression: Expr, map: (inner: Expr) => Expr): Expr =>
603
586
  mapScoped(
604
587
  undefined,
@@ -1,5 +1,4 @@
1
- // A port of OCaml's Format module, which tlapm uses to lay out obligations. Only the parts tlapm
2
- // reaches are ported: boxes, breaks, forced newlines and text.
1
+ // A port of OCaml's Format module, which tlapm uses to lay out obligations.
3
2
 
4
3
  type BoxKind = "h" | "v" | "hv" | "hov" | "b" | "fits";
5
4
 
@@ -238,7 +237,6 @@ const flush = (formatter: Formatter) => {
238
237
  return formatter.output.join("");
239
238
  };
240
239
 
241
- // pp_print_newline: flush, print a newline, and start over with no open boxes.
242
240
  const flushNewline = (formatter: Formatter) => {
243
241
  flush(formatter);
244
242
  const output = [...formatter.output, "\n"];
@@ -246,8 +244,6 @@ const flushNewline = (formatter: Formatter) => {
246
244
  formatter.output = output;
247
245
  };
248
246
 
249
- // Printers build a document of layout commands first and render it once, so names resolve while
250
- // the printer still knows the context they were bound in.
251
247
  type Command =
252
248
  | { kind: "Open"; box: BoxKind; indent: number }
253
249
  | { kind: "Close" }
@@ -262,7 +258,6 @@ const BOX_KINDS: Record<string, BoxKind> = { h: "h", v: "v", hv: "hv", hov: "hov
262
258
 
263
259
  const getText = (value: string): Command => ({ kind: "Text", text: value, size: getLength(value) });
264
260
 
265
- // Prints a string as is, where format would read @ and % in it as directives.
266
261
  export const text = (value: string): Doc => (value === "" ? [] : [getText(value)]);
267
262
 
268
263
  const SPACE: Command = { kind: "Break", width: 1, offset: 0 };
@@ -278,8 +273,6 @@ const parseOpen = (directive: string): Command => {
278
273
  };
279
274
  };
280
275
 
281
- // Interprets the subset of OCaml format strings that tlapm's printers use, so ported printers read
282
- // like the OCaml they come from. Each %s or %a consumes one argument.
283
276
  export const format = (pattern: string, ...args: (string | Doc)[]): Doc => {
284
277
  const doc: Doc = [];
285
278
  let argumentIndex = 0;
@@ -397,7 +390,6 @@ const renderInto = (formatter: Formatter, doc: Doc) => {
397
390
  }
398
391
  };
399
392
 
400
- // 68 is Format's default maximum indent; tlapm's stderr formatter allows 35.
401
393
  export const renderDoc = (doc: Doc, maxIndent = 68) => {
402
394
  const formatter = createFormatter(maxIndent);
403
395
  renderInto(formatter, doc);