tla-ts 0.0.9 → 0.0.10-dev.63a6693bd

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 (400) 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 +29 -29
  5. package/dist/deciders.js +42 -42
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +106 -10
  8. package/dist/index.d.ts +106 -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 +117 -37
  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 +129 -104
  21. package/dist/transfer.js +129 -104
  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 +48 -62
  26. package/src/bags.ts +99 -102
  27. package/src/builtins.ts +28 -75
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check-failure.ts +116 -0
  30. package/src/check-trace.ts +282 -0
  31. package/src/check.ts +599 -754
  32. package/src/cli/options.ts +12 -32
  33. package/src/cli/run.ts +0 -2
  34. package/src/cli/runtime-invariants.ts +136 -0
  35. package/src/cli/shared.ts +19 -12
  36. package/src/cli/tlapm.ts +14 -25
  37. package/src/cli/tlc-arguments.ts +652 -0
  38. package/src/cli/tlc-output.ts +687 -0
  39. package/src/cli/tlc-usage.ts +361 -0
  40. package/src/cli/tlc.ts +309 -658
  41. package/src/cli/typescript.ts +23 -0
  42. package/src/cli/xml-exporter.ts +27 -49
  43. package/src/cli.ts +0 -1
  44. package/src/codegen.ts +196 -74
  45. package/src/config.ts +140 -109
  46. package/src/coverage.ts +830 -0
  47. package/src/dependencies.ts +14 -53
  48. package/src/dfid.ts +618 -0
  49. package/src/environment-config.ts +315 -0
  50. package/src/environment.ts +169 -335
  51. package/src/errors.ts +71 -55
  52. package/src/evaluate.ts +598 -340
  53. package/src/exit-codes.ts +37 -3
  54. package/src/fingerprints.ts +75 -11
  55. package/src/index.ts +3 -0
  56. package/src/instances.ts +126 -21
  57. package/src/java-hash.ts +7 -0
  58. package/src/java-overrides.ts +4 -19
  59. package/src/json-reader.ts +455 -0
  60. package/src/json.ts +252 -139
  61. package/src/levels.ts +46 -58
  62. package/src/lexer.ts +80 -100
  63. package/src/liveness-checker.ts +103 -153
  64. package/src/liveness.ts +150 -109
  65. package/src/obligations/action.ts +8 -39
  66. package/src/obligations/anonymize.ts +88 -82
  67. package/src/obligations/equality.ts +1 -1
  68. package/src/obligations/expression.ts +20 -21
  69. package/src/obligations/format.ts +1 -9
  70. package/src/obligations/generate.ts +46 -49
  71. package/src/obligations/index.ts +2 -13
  72. package/src/obligations/levels.ts +4 -8
  73. package/src/obligations/module.ts +28 -53
  74. package/src/obligations/normalize.ts +7 -25
  75. package/src/obligations/operators.ts +1 -2
  76. package/src/obligations/pragma.ts +1 -10
  77. package/src/obligations/printer.ts +47 -46
  78. package/src/obligations/proof.ts +1 -5
  79. package/src/obligations/regroup.ts +1 -4
  80. package/src/obligations/simplify.ts +42 -58
  81. package/src/obligations/source.ts +48 -78
  82. package/src/obligations/subexpression.ts +5 -11
  83. package/src/obligations/substitution.ts +1 -3
  84. package/src/obligations/temporal.ts +13 -19
  85. package/src/obligations/tuples.ts +3 -9
  86. package/src/parallel-worker.ts +30 -60
  87. package/src/parallel.ts +57 -71
  88. package/src/parser.ts +584 -316
  89. package/src/pcal/ast.ts +53 -86
  90. package/src/pcal/parse.ts +144 -219
  91. package/src/pcal/tokenize.ts +91 -131
  92. package/src/pcal/translate.ts +83 -130
  93. package/src/pcal/validate.ts +48 -68
  94. package/src/pretty-print.ts +7 -8
  95. package/src/prover/decide-pool.ts +8 -13
  96. package/src/prover/deciders.ts +3 -7
  97. package/src/prover/first-order.ts +0 -11
  98. package/src/prover/isabelle/decide.ts +0 -6
  99. package/src/prover/isabelle/encode.ts +11 -23
  100. package/src/prover/isabelle/isar/inner-syntax.ts +114 -115
  101. package/src/prover/isabelle/isar/method.ts +29 -53
  102. package/src/prover/isabelle/isar/proof.ts +1 -10
  103. package/src/prover/isabelle/isar/statement.ts +1 -6
  104. package/src/prover/isabelle/isar/theory.ts +26 -36
  105. package/src/prover/isabelle/isar/type-check.ts +17 -31
  106. package/src/prover/isabelle/provers/blast/blast.ts +17 -104
  107. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  108. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  109. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  110. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  111. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  112. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  113. package/src/prover/isabelle/provers/classical.ts +14 -42
  114. package/src/prover/isabelle/provers/hypsubst.ts +28 -51
  115. package/src/prover/isabelle/pure/bicompose.ts +25 -38
  116. package/src/prover/isabelle/pure/consts.ts +1 -7
  117. package/src/prover/isabelle/pure/conv.ts +3 -17
  118. package/src/prover/isabelle/pure/drule.ts +33 -42
  119. package/src/prover/isabelle/pure/envir.ts +3 -52
  120. package/src/prover/isabelle/pure/goal.ts +1 -7
  121. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  122. package/src/prover/isabelle/pure/list.ts +0 -3
  123. package/src/prover/isabelle/pure/logic.ts +2 -15
  124. package/src/prover/isabelle/pure/name.ts +2 -9
  125. package/src/prover/isabelle/pure/net.ts +3 -59
  126. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  127. package/src/prover/isabelle/pure/pattern.ts +2 -19
  128. package/src/prover/isabelle/pure/raw-simplifier.ts +17 -62
  129. package/src/prover/isabelle/pure/rewriter.ts +31 -67
  130. package/src/prover/isabelle/pure/search.ts +3 -10
  131. package/src/prover/isabelle/pure/seq.ts +1 -10
  132. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  133. package/src/prover/isabelle/pure/table.ts +3 -32
  134. package/src/prover/isabelle/pure/tactic.ts +12 -22
  135. package/src/prover/isabelle/pure/tactical.ts +48 -47
  136. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  137. package/src/prover/isabelle/pure/term.ts +2 -43
  138. package/src/prover/isabelle/pure/thm.ts +27 -47
  139. package/src/prover/isabelle/pure/type.ts +2 -15
  140. package/src/prover/isabelle/pure/unify.ts +20 -30
  141. package/src/prover/isabelle/pure/variable.ts +3 -7
  142. package/src/prover/isabelle/tla/classical-setup.ts +17 -24
  143. package/src/prover/isabelle/tla/context.ts +15 -18
  144. package/src/prover/isabelle/tla/logic.ts +14 -32
  145. package/src/prover/isabelle/tla/simpdata.ts +46 -43
  146. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  147. package/src/prover/ocaml.ts +0 -6
  148. package/src/prover/prep/action.ts +14 -54
  149. package/src/prover/prep/enabled-axioms.ts +12 -19
  150. package/src/prover/prep/fingerprint.ts +2 -21
  151. package/src/prover/prep/level-comparison.ts +8 -12
  152. package/src/prover/prep/md5.ts +0 -2
  153. package/src/prover/prep/methods.ts +33 -39
  154. package/src/prover/prep/normalize.ts +4 -28
  155. package/src/prover/prove-worker.ts +0 -2
  156. package/src/prover/prove.ts +87 -100
  157. package/src/prover/ptl/decide.ts +7 -12
  158. package/src/prover/ptl/encode.ts +14 -36
  159. package/src/prover/ptl/sat.ts +24 -32
  160. package/src/prover/ptl/tableau.ts +12 -26
  161. package/src/prover/smt/axioms.ts +0 -7
  162. package/src/prover/smt/context.ts +20 -28
  163. package/src/prover/smt/data.ts +433 -424
  164. package/src/prover/smt/encode.ts +43 -52
  165. package/src/prover/smt/extensionality.ts +0 -10
  166. package/src/prover/smt/flatten.ts +3 -22
  167. package/src/prover/smt/format.ts +5 -10
  168. package/src/prover/smt/instances.ts +0 -10
  169. package/src/prover/smt/rewrite.ts +663 -667
  170. package/src/prover/smt/solver/act-cache.ts +0 -15
  171. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  172. package/src/prover/smt/solver/array.ts +1 -3
  173. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  174. package/src/prover/smt/solver/ast-lt.ts +1 -11
  175. package/src/prover/smt/solver/ast-util.ts +1 -6
  176. package/src/prover/smt/solver/ast.ts +1 -165
  177. package/src/prover/smt/solver/auf-solver.ts +8 -44
  178. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  179. package/src/prover/smt/solver/cg-table.ts +1 -18
  180. package/src/prover/smt/solver/clause.ts +1 -27
  181. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  182. package/src/prover/smt/solver/context.ts +7 -64
  183. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  184. package/src/prover/smt/solver/der.ts +2 -21
  185. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  186. package/src/prover/smt/solver/e-matching.ts +4 -35
  187. package/src/prover/smt/solver/enode.ts +1 -21
  188. package/src/prover/smt/solver/expr-ref.ts +1 -5
  189. package/src/prover/smt/solver/expr-safe-replace.ts +1 -6
  190. package/src/prover/smt/solver/fingerprints.ts +1 -12
  191. package/src/prover/smt/solver/flat-literals.ts +1 -9
  192. package/src/prover/smt/solver/goal.ts +2 -14
  193. package/src/prover/smt/solver/hash.ts +0 -8
  194. package/src/prover/smt/solver/hashtable.ts +1 -12
  195. package/src/prover/smt/solver/internalizer.ts +7 -100
  196. package/src/prover/smt/solver/lbool.ts +1 -2
  197. package/src/prover/smt/solver/literal.ts +0 -3
  198. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  199. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  200. package/src/prover/smt/solver/lp/containers.ts +12 -30
  201. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  202. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  203. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  204. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  205. package/src/prover/smt/solver/lp/dioph-eq.ts +9 -102
  206. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  207. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  208. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  209. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  210. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  211. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  212. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  213. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  214. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  215. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  216. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  217. package/src/prover/smt/solver/lp/nex.ts +1 -6
  218. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  220. package/src/prover/smt/solver/lp/nla-core.ts +36 -135
  221. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  222. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  223. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  224. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  225. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  226. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  227. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  228. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  229. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  230. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  231. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  232. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  233. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  234. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  235. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  236. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  237. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  238. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  239. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  240. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  241. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  242. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  243. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  244. package/src/prover/smt/solver/mam-compiler.ts +18 -58
  245. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  246. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  247. package/src/prover/smt/solver/model-checker.ts +3 -37
  248. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  249. package/src/prover/smt/solver/model-finder.ts +15 -32
  250. package/src/prover/smt/solver/model-generator.ts +1 -12
  251. package/src/prover/smt/solver/model-macro-solver.ts +23 -88
  252. package/src/prover/smt/solver/nlsat/algebraic.ts +63 -159
  253. package/src/prover/smt/solver/nlsat/atoms.ts +25 -23
  254. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  255. package/src/prover/smt/solver/nlsat/explain.ts +10 -69
  256. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  257. package/src/prover/smt/solver/nlsat/levelwise.ts +49 -135
  258. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  259. package/src/prover/smt/solver/nlsat/polynomial.ts +29 -159
  260. package/src/prover/smt/solver/nlsat/solver.ts +18 -90
  261. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  262. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +2 -45
  263. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  264. package/src/prover/smt/solver/nnf.ts +3 -38
  265. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  266. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  267. package/src/prover/smt/solver/propagate-values.ts +1 -10
  268. package/src/prover/smt/solver/proto-model.ts +3 -52
  269. package/src/prover/smt/solver/pull-quant.ts +1 -12
  270. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  271. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  272. package/src/prover/smt/solver/qe-lite.ts +3 -33
  273. package/src/prover/smt/solver/qi-queue.ts +1 -16
  274. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  275. package/src/prover/smt/solver/quantifier-analyzer.ts +27 -47
  276. package/src/prover/smt/solver/quantifier-manager.ts +2 -13
  277. package/src/prover/smt/solver/random-gen.ts +1 -2
  278. package/src/prover/smt/solver/rational.ts +1 -8
  279. package/src/prover/smt/solver/ref-vector.ts +1 -6
  280. package/src/prover/smt/solver/relevancy.ts +2 -15
  281. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  282. package/src/prover/smt/solver/rewriter.ts +3 -85
  283. package/src/prover/smt/solver/rlimit.ts +2 -20
  284. package/src/prover/smt/solver/smtlib-parser.ts +80 -131
  285. package/src/prover/smt/solver/solver.ts +23 -34
  286. package/src/prover/smt/solver/sort.ts +1 -5
  287. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  288. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  289. package/src/prover/smt/solver/theory-lra-bounds.ts +1 -7
  290. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  291. package/src/prover/smt/solver/theory-lra-internalize.ts +6 -43
  292. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  293. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  294. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  295. package/src/prover/smt/solver/theory-lra.ts +1 -8
  296. package/src/prover/smt/solver/var-subst.ts +2 -26
  297. package/src/prover/smt/table.ts +0 -8
  298. package/src/prover/tlapm/cache.ts +45 -40
  299. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  300. package/src/prover/tlapm/tlapm.ts +21 -20
  301. package/src/prover/verdict.ts +7 -2
  302. package/src/prover/zenon/check/check.ts +1 -11
  303. package/src/prover/zenon/check/definitions.ts +5 -15
  304. package/src/prover/zenon/check/equality.ts +0 -8
  305. package/src/prover/zenon/check/functions.ts +0 -4
  306. package/src/prover/zenon/check/keys.ts +0 -7
  307. package/src/prover/zenon/check/propositional.ts +0 -3
  308. package/src/prover/zenon/check/records.ts +1 -6
  309. package/src/prover/zenon/check/relations.ts +2 -14
  310. package/src/prover/zenon/check/rewrites.ts +2 -21
  311. package/src/prover/zenon/check/sets.ts +40 -61
  312. package/src/prover/zenon/check/terms.ts +1 -19
  313. package/src/prover/zenon/check/tla.ts +0 -6
  314. package/src/prover/zenon/decide.ts +0 -12
  315. package/src/prover/zenon/encode.ts +1 -8
  316. package/src/prover/zenon/eqrel.ts +2 -13
  317. package/src/prover/zenon/equality-rules.ts +0 -4
  318. package/src/prover/zenon/expr.ts +8 -26
  319. package/src/prover/zenon/index-table.ts +26 -57
  320. package/src/prover/zenon/isar-case.ts +9 -19
  321. package/src/prover/zenon/isar.ts +36 -64
  322. package/src/prover/zenon/limits.ts +0 -4
  323. package/src/prover/zenon/llproof.ts +2 -20
  324. package/src/prover/zenon/mltoll.ts +66 -104
  325. package/src/prover/zenon/node.ts +1 -11
  326. package/src/prover/zenon/ocaml.ts +1 -17
  327. package/src/prover/zenon/parse.ts +4 -12
  328. package/src/prover/zenon/phrase.ts +1 -11
  329. package/src/prover/zenon/proof.ts +0 -9
  330. package/src/prover/zenon/propositional-rules.ts +0 -5
  331. package/src/prover/zenon/rules.ts +2 -6
  332. package/src/prover/zenon/search.ts +5 -31
  333. package/src/prover/zenon/tla/functions.ts +59 -31
  334. package/src/prover/zenon/tla/llproof.ts +67 -76
  335. package/src/prover/zenon/tla/records.ts +57 -33
  336. package/src/prover/zenon/tla/rewrites.ts +12 -19
  337. package/src/prover/zenon/tla/sets.ts +83 -53
  338. package/src/prover/zenon/tla/terms.ts +0 -6
  339. package/src/prover/zenon/tla/tla.ts +66 -64
  340. package/src/randomization.ts +81 -35
  341. package/src/resolve.ts +67 -184
  342. package/src/runtime.ts +22 -22
  343. package/src/sany/builtins.ts +2 -5
  344. package/src/sany/generation.ts +394 -0
  345. package/src/sany/generator-def-entries.ts +210 -0
  346. package/src/sany/generator-definitions.ts +686 -0
  347. package/src/sany/generator-expressions.ts +1100 -0
  348. package/src/sany/generator-proofs.ts +662 -0
  349. package/src/sany/generator.ts +191 -2764
  350. package/src/sany/levels.ts +6 -34
  351. package/src/sany/lexer.ts +58 -77
  352. package/src/sany/linter.ts +1 -9
  353. package/src/sany/modules.ts +1 -5
  354. package/src/sany/nodes.ts +5 -43
  355. package/src/sany/parse-error.ts +39 -117
  356. package/src/sany/report.ts +32 -69
  357. package/src/sany/selectors.ts +49 -76
  358. package/src/sany/source.ts +1 -17
  359. package/src/sany/xml.ts +35 -117
  360. package/src/search.ts +541 -163
  361. package/src/simulate.ts +709 -0
  362. package/src/spec-description.ts +192 -100
  363. package/src/standard-definitions.ts +0 -4
  364. package/src/standard-modules.ts +264 -95
  365. package/src/state-graph.ts +52 -31
  366. package/src/subexpressions.ts +69 -52
  367. package/src/substitution-levels.ts +7 -7
  368. package/src/successors.ts +266 -99
  369. package/src/symmetry.ts +33 -25
  370. package/src/tableau.ts +27 -24
  371. package/src/tlc/fingerprint.ts +183 -67
  372. package/src/tlc/jar-data.ts +112 -6
  373. package/src/tlc/messages.ts +125 -54
  374. package/src/tlc/order.ts +39 -69
  375. package/src/tlc/random.ts +37 -49
  376. package/src/tlc/replay.ts +553 -228
  377. package/src/tlc/summary.ts +36 -47
  378. package/src/tlc/tlc-operators.ts +78 -44
  379. package/src/tlc/tlcext-operators.ts +139 -122
  380. package/src/tlc/trace-spec.ts +249 -0
  381. package/src/tlc/value-stream.ts +139 -0
  382. package/src/tlc/version.ts +1 -4
  383. package/src/transfer.ts +22 -25
  384. package/src/typescript/actions.ts +479 -0
  385. package/src/typescript/collections.ts +614 -0
  386. package/src/typescript/compile.ts +63 -0
  387. package/src/typescript/context.ts +94 -0
  388. package/src/typescript/emit.ts +121 -0
  389. package/src/typescript/expressions.ts +496 -0
  390. package/src/typescript/formula.ts +154 -0
  391. package/src/typescript/functions.ts +284 -0
  392. package/src/typescript/model.ts +162 -0
  393. package/src/typescript/names.ts +114 -0
  394. package/src/typescript/program.ts +48 -0
  395. package/src/typescript/properties.ts +139 -0
  396. package/src/typescript/scope.ts +112 -0
  397. package/src/typescript/steps.ts +167 -0
  398. package/src/typescript/types.ts +171 -0
  399. package/src/values.ts +832 -484
  400. package/src/worker.ts +7 -8
@@ -1,6 +1,4 @@
1
- // A port of tlapm's Expr.Action. Lambdifying gives each ENABLED and \cdot a LAMBDA over the
2
- // variables it binds, after expanding the definitions soundness needs expanded. The ExpandENABLED
3
- // and ExpandCdot frontends then replace each LAMBDA with an existential quantifier.
1
+ // A port of tlapm's Expr.Action.
4
2
 
5
3
  import { TlaProofError, TlapmBugError, TlaProverError } from "../errors";
6
4
  import type { Anonymizer } from "./anonymize";
@@ -16,6 +14,7 @@ import {
16
14
  getParamFresh,
17
15
  getScopeAt,
18
16
  isBuiltinApply,
17
+ mapChildren,
19
18
  mapScoped,
20
19
  stripProps,
21
20
  type Expr,
@@ -26,8 +25,6 @@ import {
26
25
  import { getLevelInfo, LEVEL_NUMBERS } from "./levels";
27
26
  import { rewriteUnchanged } from "./temporal";
28
27
 
29
- // Which of ENABLED and \cdot a pass handles, and whether it may expand the definitions that
30
- // soundness needs expanded, as the AutoUSE directive allows.
31
28
  interface ActionOptions {
32
29
  isEnabled: boolean;
33
30
  isCdot: boolean;
@@ -48,18 +45,8 @@ const NESTED_ENABLED =
48
45
  const NESTED_CDOT =
49
46
  "Nested occurrence of the operator `\\cdot` found in scope of `ENABLED` when expanding `ENABLED`. Using the proof directive `ExpandCdot` from the module `TLAPS` is expected to avoid this error.";
50
47
 
51
- // Unlike auto_expansion_of_defs, tlapm puts a space before "For example" here.
52
48
  const NESTED_CDOT_SPACED = `${NESTED_CDOT} For example, writing \`BY ExpandCdot\`.`;
53
49
 
54
- // Visit.map_visible_hyp with no state.
55
- const mapVisibleChildren = (expression: Expr, map: (child: Expr) => Expr) =>
56
- mapScoped(
57
- undefined,
58
- expression,
59
- (_state, child) => map(child),
60
- () => undefined,
61
- );
62
-
63
50
  const getHyp = (scope: Scope | undefined, index: number) => {
64
51
  const hyp = getScopeAt(scope, index - 1)?.hyp;
65
52
  if (!hyp) throw new TlapmBugError();
@@ -88,8 +75,6 @@ const getInitialLevel = (level: number | undefined) =>
88
75
  const getDecrementedLevel = (level: number | undefined) =>
89
76
  level === undefined ? undefined : Math.max(1, level - 1);
90
77
 
91
- // auto_expansion_of_defs. ENABLED and the first argument of \cdot need every definition of action
92
- // level expanded, a prime lowers that bound to 1, and so does the second argument of \cdot.
93
78
  const expandDefinitions = (
94
79
  options: ActionOptions,
95
80
  onWarning: Warn,
@@ -209,7 +194,6 @@ const expandDefinitions = (
209
194
  );
210
195
  };
211
196
 
212
- // expand_propositional_action_operators: UNCHANGED v, [A]_v and <<A>>_v in terms of primes.
213
197
  const expandPropositional = (expression: Expr): Expr => {
214
198
  if (expression.kind === "Apply" && expression.args.length === 1) {
215
199
  return rewriteUnchanged(expression.args[0]);
@@ -225,8 +209,7 @@ const expandPropositional = (expression: Expr): Expr => {
225
209
  );
226
210
  };
227
211
 
228
- // OCaml's Hashtbl.hash of a string: caml_hash's MurmurHash3 over the bytes.
229
- const getHash = (text: string) => {
212
+ const getOcamlHash = (text: string) => {
230
213
  const rotate = (value: number, amount: number) => (value << amount) | (value >>> (32 - amount));
231
214
  const mix = (hash: number, data: number) => {
232
215
  const word = Math.imul(rotate(Math.imul(data, 0xcc9e2d51), 15), 0x1b873593);
@@ -249,23 +232,18 @@ const getHash = (text: string) => {
249
232
  return (hash ^ (hash >>> 16)) & 0x3fffffff;
250
233
  };
251
234
 
252
- // The keys of an OCaml Hashtbl.create 16 in Hashtbl.to_seq_keys order. Hashtbl.add prepends to a
253
- // bucket and doubles the buckets once the table holds more than twice their count.
254
235
  const getHashtblKeys = (names: string[]) => {
255
236
  let buckets: string[][] = Array.from({ length: 16 }, () => []);
256
237
  names.forEach((name, index) => {
257
- buckets[getHash(name) & (buckets.length - 1)].unshift(name);
238
+ buckets[getOcamlHash(name) & (buckets.length - 1)].unshift(name);
258
239
  if (index + 1 <= buckets.length * 2) return;
259
240
  const resized: string[][] = Array.from({ length: buckets.length * 2 }, () => []);
260
- buckets.flat().forEach((key) => resized[getHash(key) & (resized.length - 1)].push(key));
241
+ buckets.flat().forEach((key) => resized[getOcamlHash(key) & (resized.length - 1)].push(key));
261
242
  buckets = resized;
262
243
  });
263
244
  return buckets.flat();
264
245
  };
265
246
 
266
- // lambdify_action_operators. A variable met directly binds into current, and one met under a prime
267
- // into primed. ENABLED A binds the primes of A, and A \cdot B binds those of A and the unprimed
268
- // variables of B, each as an opaque name such as x#enabled#prime1.
269
247
  const bindVariables = (
270
248
  options: ActionOptions,
271
249
  onWarning: Warn,
@@ -354,8 +332,6 @@ const bindVariables = (
354
332
  );
355
333
  };
356
334
 
357
- // shift_indices_after_lambdify, a Subst.map_visible_hyp that makes room in each new LAMBDA body
358
- // for its parameters and drops the placeholder parameter.
359
335
  const shiftIndices = (substitution: Substitution, expression: Expr): Expr => {
360
336
  if (expression.kind === "Apply" && isActionOperator(expression.operator)) {
361
337
  const [lambda] = expression.args;
@@ -387,7 +363,6 @@ const shiftIndices = (substitution: Substitution, expression: Expr): Expr => {
387
363
  return mapScoped(substitution, expression, shiftIndices, (current) => bumpBy(1, current));
388
364
  };
389
365
 
390
- // normalize_lambda_param_names.
391
366
  const renameParams = (isKeepingNames: boolean, expression: Expr): Expr => {
392
367
  if (expression.kind === "Apply" && isActionOperator(expression.operator)) {
393
368
  const [lambda] = expression.args;
@@ -410,10 +385,9 @@ const renameParams = (isKeepingNames: boolean, expression: Expr): Expr => {
410
385
  ],
411
386
  };
412
387
  }
413
- return mapVisibleChildren(expression, (child) => renameParams(isKeepingNames, child));
388
+ return mapChildren(expression, (child) => renameParams(isKeepingNames, child), "visible");
414
389
  };
415
390
 
416
- // check_arity.
417
391
  const checkArity = (expression: Expr): Expr => {
418
392
  if (
419
393
  isBuiltinApply(expression, "Cdot") &&
@@ -422,10 +396,9 @@ const checkArity = (expression: Expr): Expr => {
422
396
  ) {
423
397
  throw new TlapmBugError();
424
398
  }
425
- return mapVisibleChildren(expression, checkArity);
399
+ return mapChildren(expression, checkArity, "visible");
426
400
  };
427
401
 
428
- // lambdify_action_operators#expand.
429
402
  const lambdifyOperators = (
430
403
  anonymizer: Anonymizer,
431
404
  onWarning: Warn,
@@ -451,8 +424,6 @@ export const lambdify = (
451
424
  return checkArity(lambdifyOperators(anonymizer, onWarning, scope, expanded, options, false));
452
425
  };
453
426
 
454
- // replace_action_operators_with_quantifiers: each lambdified ENABLED or \cdot that the frontend
455
- // expands becomes \E over the parameters of its LAMBDA.
456
427
  const replaceWithQuantifiers = (
457
428
  options: ActionOptions,
458
429
  onWarning: Warn,
@@ -521,7 +492,6 @@ const replaceWithQuantifiers = (
521
492
  );
522
493
  };
523
494
 
524
- // commute_exists_disjunction: \E x : A \/ B as (\E x : A) \/ (\E x : B), everywhere.
525
495
  const commuteExistsDisjunction = (expression: Expr): Expr => {
526
496
  if (expression.kind === "Quant" && expression.quantifier === "Exists") {
527
497
  const body = expression.body;
@@ -539,10 +509,9 @@ const commuteExistsDisjunction = (expression: Expr): Expr => {
539
509
  });
540
510
  }
541
511
  }
542
- return mapVisibleChildren(expression, commuteExistsDisjunction);
512
+ return mapChildren(expression, commuteExistsDisjunction, "visible");
543
513
  };
544
514
 
545
- // expand_action_operators, the ExpandENABLED and ExpandCdot frontends.
546
515
  export const expandActionOperators = (
547
516
  anonymizer: Anonymizer,
548
517
  onWarning: Warn,
@@ -1,10 +1,10 @@
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";
6
5
  import { isEqualExpr } from "./equality";
7
6
  import {
7
+ AT_NOWHERE,
8
8
  adjoin,
9
9
  adjoinAll,
10
10
  applyBuiltin,
@@ -17,6 +17,7 @@ import {
17
17
  getLocalDefn,
18
18
  getLocusPrefix,
19
19
  getScopeAt,
20
+ getTrue,
20
21
  mapAccumulate,
21
22
  mapBoundDomains,
22
23
  mapScoped,
@@ -49,7 +50,7 @@ import {
49
50
 
50
51
  const DUMMY_FACT: Hyp = {
51
52
  kind: "Fact",
52
- expression: { kind: "At", isExcept: false },
53
+ expression: AT_NOWHERE,
53
54
  visibility: "Visible",
54
55
  time: "Always",
55
56
  };
@@ -65,7 +66,6 @@ const ANON_SELECTOR_FAILURES = {
65
66
 
66
67
  const BAD_EXPRESSION: Expr = { kind: "Opaque", name: "$badexp" };
67
68
 
68
- // Util.set_locus: the node keeps its properties and takes the location of from.
69
69
  const withLocus = (expression: Expr, from: Expr) =>
70
70
  from.location ? { ...expression, location: from.location } : expression;
71
71
 
@@ -82,20 +82,19 @@ export const createAnonymizer = (
82
82
  ) => Defn[],
83
83
  onWarning: Warn,
84
84
  ) => {
85
- // Elab.desugar's current_at: the value @ stands for inside an EXCEPT, and the context size there.
86
85
  let currentAt: { expression: Expr; size: number } | undefined;
87
86
 
88
87
  const getContext = (scope: Scope | undefined): AnonContext => ({ warnedSteps: [], scope });
89
88
 
90
89
  const getSize = (context: AnonContext) => context.scope?.size ?? 0;
91
90
 
92
- const expr = (context: AnonContext, expression: Expr): Expr => {
91
+ const anonymizeExpr = (context: AnonContext, expression: Expr): Expr => {
93
92
  if (expression.kind === "At" && expression.isExcept) {
94
93
  if (!currentAt) return expression;
95
94
  return shiftExpr(getSize(context) - currentAt.size, currentAt.expression);
96
95
  }
97
- if (expression.kind !== "Except") return anonCore(context, expression);
98
- const base = expr(context, expression.function);
96
+ if (expression.kind !== "Except") return anonymizeCore(context, expression);
97
+ const base = anonymizeExpr(context, expression.function);
99
98
  return expression.specs.reduce((result, spec) => {
100
99
  const [path, trail] = mapAccumulate(
101
100
  result,
@@ -104,7 +103,7 @@ export const createAnonymizer = (
104
103
  if (point.kind === "Dot") {
105
104
  return [at({ kind: "Dot", expression: current, field: point.field }, current), point];
106
105
  }
107
- const key = expr(context, point.expression);
106
+ const key = anonymizeExpr(context, point.expression);
108
107
  return [
109
108
  at({ kind: "FcnApp", function: current, args: [key] }, current),
110
109
  { kind: "Apply", expression: key },
@@ -113,25 +112,25 @@ export const createAnonymizer = (
113
112
  );
114
113
  const saved = currentAt;
115
114
  currentAt = { expression: path, size: getSize(context) };
116
- const value = expr(context, spec.value);
115
+ const value = anonymizeExpr(context, spec.value);
117
116
  currentAt = saved;
118
117
  return at({ kind: "Except", function: result, specs: [{ trail, value }] }, expression);
119
118
  }, base);
120
119
  };
121
120
 
122
- const anonApply = (index: number, args: Expr[], from: Expr): Expr => {
121
+ const createAnonApply = (index: number, args: Expr[], from: Expr): Expr => {
123
122
  const indexed = at({ kind: "Ix", index }, from);
124
123
  return args.length === 0 ? indexed : at({ kind: "Apply", operator: indexed, args }, from);
125
124
  };
126
125
 
127
- const standardForm = (
126
+ const createStandardForm = (
128
127
  index: number,
129
128
  whereDefined: WhereDefined,
130
129
  body: Expr,
131
130
  args: Expr[],
132
131
  from: Expr,
133
132
  ): Expr => {
134
- if (whereDefined !== "Builtin") return anonApply(index, args, from);
133
+ if (whereDefined !== "Builtin") return createAnonApply(index, args, from);
135
134
  const shifted = shiftExpr(index, body);
136
135
  return at(args.length === 0 ? shifted : normalizeApply(shifted, args), from);
137
136
  };
@@ -149,16 +148,16 @@ export const createAnonymizer = (
149
148
  case "Defn": {
150
149
  const definition = hyp.definition;
151
150
  if (definition.kind === "Operator") {
152
- return standardForm(index, hyp.whereDefined, definition.body, args, from);
151
+ return createStandardForm(index, hyp.whereDefined, definition.body, args, from);
153
152
  }
154
153
  if (definition.kind === "Recursive")
155
154
  throw new TlaProofError("Recursive operators not supported by TLAPS", {
156
155
  failure: "Expr.Anon: Recursive",
157
156
  });
158
- return anonApply(index, args, from);
157
+ return createAnonApply(index, args, from);
159
158
  }
160
159
  case "Fresh":
161
- return anonApply(index, args, from);
160
+ return createAnonApply(index, args, from);
162
161
  case "Flex":
163
162
  return at({ kind: "Ix", index }, from);
164
163
  case "Fact":
@@ -168,7 +167,6 @@ export const createAnonymizer = (
168
167
  }
169
168
  };
170
169
 
171
- // Expr.Anon's check: a prefix that names nothing joins the next label, as in an instance path.
172
170
  const resolveBang = (
173
171
  context: AnonContext,
174
172
  prefix: string,
@@ -181,7 +179,7 @@ export const createAnonymizer = (
181
179
  if (!found) {
182
180
  const [selector, ...rest] = selectors;
183
181
  if (selector?.kind === "Label") {
184
- const labelArgs = selector.args.map((arg) => expr(context, arg));
182
+ const labelArgs = selector.args.map((arg) => anonymizeExpr(context, arg));
185
183
  return resolveBang(
186
184
  context,
187
185
  `${prefix}!${selector.label}`,
@@ -208,25 +206,25 @@ export const createAnonymizer = (
208
206
  if (selectors.length === 0 && isInstance) {
209
207
  return args.length === 0
210
208
  ? at({ kind: "Ix", index }, from)
211
- : standardForm(index, hyp.whereDefined, hyp.definition.body, args, from);
209
+ : createStandardForm(index, hyp.whereDefined, hyp.definition.body, args, from);
212
210
  }
213
211
  const body = withLocus(shiftExpr(index, hyp.definition.body), from);
214
212
  return withLocus(resolveSubexpression(onWarning, body, args, selectors), from);
215
213
  };
216
214
 
217
- const anonCore = (context: AnonContext, expression: Expr): Expr => {
215
+ const anonymizeCore = (context: AnonContext, expression: Expr): Expr => {
218
216
  switch (expression.kind) {
219
217
  case "Bang": {
220
218
  const inner = expression.expression;
221
219
  if (inner.kind === "Apply" && inner.operator.kind === "Opaque") {
222
220
  const selectors = expression.selectors.map((selector) =>
223
- mapSelectorArgs(selector, (arg) => expr(context, arg)),
221
+ mapSelectorArgs(selector, (arg) => anonymizeExpr(context, arg)),
224
222
  );
225
- const args = inner.args.map((arg) => expr(context, arg));
223
+ const args = inner.args.map((arg) => anonymizeExpr(context, arg));
226
224
  const bangContext = getContext(context.scope);
227
225
  return resolveBang(bangContext, inner.operator.name, args, selectors, false, expression);
228
226
  }
229
- return expr(context, {
227
+ return anonymizeExpr(context, {
230
228
  ...expression,
231
229
  expression: at({ kind: "Apply", operator: inner, args: [] }, inner),
232
230
  });
@@ -239,26 +237,29 @@ export const createAnonymizer = (
239
237
  text: `${getLocusPrefix(expression.location)}Warning: ${name} does not introduce any assumptions. It does not make sense to use it here.\n`,
240
238
  channel: "toolbox",
241
239
  });
242
- return at({ kind: "Internal", builtin: "TRUE" }, expression);
240
+ return getTrue(expression);
243
241
  }
244
- const args = expression.args.map((arg) => expr(context, arg));
242
+ const args = expression.args.map((arg) => anonymizeExpr(context, arg));
245
243
  return resolveName(context, name, args, expression);
246
244
  }
247
245
  case "Opaque":
248
- return expr(context, at({ kind: "Apply", operator: expression, args: [] }, expression));
246
+ return anonymizeExpr(
247
+ context,
248
+ at({ kind: "Apply", operator: expression, args: [] }, expression),
249
+ );
249
250
  case "Parens":
250
- if (expression.form.kind === "Syntax") return expr(context, expression.expression);
251
+ if (expression.form.kind === "Syntax") return anonymizeExpr(context, expression.expression);
251
252
  return {
252
253
  ...expression,
253
- expression: expr(context, expression.expression),
254
- form: anonParenForm(context, expression.form),
254
+ expression: anonymizeExpr(context, expression.expression),
255
+ form: anonymizeParenForm(context, expression.form),
255
256
  };
256
257
  default:
257
258
  return visit(context, expression);
258
259
  }
259
260
  };
260
261
 
261
- const anonParenForm = (context: AnonContext, form: ParenForm): ParenForm => {
262
+ const anonymizeParenForm = (context: AnonContext, form: ParenForm): ParenForm => {
262
263
  if (form.kind !== "Nlabel") return form;
263
264
  return {
264
265
  kind: "Xlabel",
@@ -282,29 +283,30 @@ export const createAnonymizer = (
282
283
  const adjoinBounds = (context: AnonContext, items: Bound[]) =>
283
284
  withScope(context, adjoinAll(context.scope, items.map(getBoundFresh)));
284
285
 
285
- const bounds = (context: AnonContext, items: Bound[]): [AnonContext, Bound[]] => {
286
- const mapped = mapBoundDomains(items, (domain) => expr(context, domain));
286
+ const anonymizeBounds = (context: AnonContext, items: Bound[]): [AnonContext, Bound[]] => {
287
+ const mapped = mapBoundDomains(items, (domain) => anonymizeExpr(context, domain));
287
288
  return [adjoinBounds(context, mapped), mapped];
288
289
  };
289
290
 
290
- // Visit.map, apart from the definitions an ASSUME or a LET binds.
291
291
  const visit = (context: AnonContext, expression: Expr): Expr => {
292
292
  if (expression.kind === "Sequent") {
293
- return { ...expression, sequent: sequent(context, expression.sequent)[1] };
293
+ return { ...expression, sequent: anonymizeSequent(context, expression.sequent)[1] };
294
294
  }
295
295
  if (expression.kind === "Let") {
296
- const [inner, definitions] = defns(context, expression.definitions);
297
- return { ...expression, definitions, body: expr(inner, expression.body) };
296
+ const [inner, definitions] = anonymizeDefns(context, expression.definitions);
297
+ return { ...expression, definitions, body: anonymizeExpr(inner, expression.body) };
298
298
  }
299
- return mapScoped(context, expression, expr, adjoinContext);
299
+ return mapScoped(context, expression, anonymizeExpr, adjoinContext);
300
300
  };
301
301
 
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 => {
302
+ const anonymizeDefn = (context: AnonContext, definition: Defn): Defn => {
304
303
  if (definition.kind !== "Operator") return definition;
305
304
  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);
305
+ if (body.kind !== "Fcn") return { ...definition, body: anonymizeExpr(context, body) };
306
+ const inner = anonymizeExpr(
307
+ adjoinContext(context, getFresh(definition.name, "Constant")),
308
+ body,
309
+ );
308
310
  const marker: Expr = { kind: "Opaque", name: "%%%" };
309
311
  const isRecursive = !isEqualExpr(
310
312
  substituteExpr(consSubstitution(marker, shift(1)), inner),
@@ -318,8 +320,7 @@ export const createAnonymizer = (
318
320
  };
319
321
  };
320
322
 
321
- // Module.Elab.anon#defns: an INSTANCE stands for the definitions it instantiates.
322
- const defns = (context: AnonContext, definitions: Defn[]): [AnonContext, Defn[]] => {
323
+ const anonymizeDefns = (context: AnonContext, definitions: Defn[]): [AnonContext, Defn[]] => {
323
324
  let current = context;
324
325
  const queue = [...definitions];
325
326
  const mapped: Defn[] = [];
@@ -329,24 +330,24 @@ export const createAnonymizer = (
329
330
  queue.splice(index + 1, 0, ...expandInstance(current.scope, definition));
330
331
  continue;
331
332
  }
332
- const result = defn(current, definition);
333
+ const result = anonymizeDefn(current, definition);
333
334
  current = adjoinContext(current, { ...getLocalDefn(result), isConstnessUnset: true });
334
335
  mapped.push(result);
335
336
  }
336
337
  return [current, mapped];
337
338
  };
338
339
 
339
- const hyp = (context: AnonContext, item: Hyp): [AnonContext, Hyp] => {
340
+ const anonymizeHyp = (context: AnonContext, item: Hyp): [AnonContext, Hyp] => {
340
341
  const mapped = ((): Hyp => {
341
342
  switch (item.kind) {
342
343
  case "Fresh":
343
- return item.domain ? { ...item, domain: expr(context, item.domain) } : item;
344
+ return item.domain ? { ...item, domain: anonymizeExpr(context, item.domain) } : item;
344
345
  case "Flex":
345
346
  return item;
346
347
  case "Defn":
347
- return { ...item, definition: defn(context, item.definition) };
348
+ return { ...item, definition: anonymizeDefn(context, item.definition) };
348
349
  case "Fact": {
349
- const expression = expr(context, item.expression);
350
+ const expression = anonymizeExpr(context, item.expression);
350
351
  return { ...item, expression, time: getTime(context.scope, expression) };
351
352
  }
352
353
  }
@@ -354,9 +355,9 @@ export const createAnonymizer = (
354
355
  return [adjoinContext(context, mapped), mapped];
355
356
  };
356
357
 
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) }];
358
+ const anonymizeSequent = (context: AnonContext, item: Sequent): [AnonContext, Sequent] => {
359
+ const [inner, hyps] = mapAccumulate(context, item.context, anonymizeHyp);
360
+ return [inner, { context: hyps, active: anonymizeExpr(inner, item.active) }];
360
361
  };
361
362
 
362
363
  const pushWarnedStep = (context: AnonContext, step: StepNumber): AnonContext => ({
@@ -384,7 +385,7 @@ export const createAnonymizer = (
384
385
  ),
385
386
  );
386
387
 
387
- const tupleForm = (item: Sequent): ExprCore => {
388
+ const getTupleForm = (item: Sequent): ExprCore => {
388
389
  const facts = item.context.map((entry, index) => {
389
390
  const amount = item.context.length - index + 1;
390
391
  if (entry.kind === "Fact") return shiftExpr(amount, entry.expression);
@@ -403,11 +404,11 @@ export const createAnonymizer = (
403
404
  const isCitable = (step: Step) =>
404
405
  step.kind !== "Use" && step.kind !== "Hide" && step.kind !== "Define";
405
406
 
406
- const usable = (context: AnonContext, item: Usable): Usable => ({
407
- facts: item.facts.map((fact) => expr(context, fact)),
407
+ const anonymizeUsable = (context: AnonContext, item: Usable): Usable => ({
408
+ facts: item.facts.map((fact) => anonymizeExpr(context, fact)),
408
409
  defs: item.defs.flatMap((def): UseDef[] => {
409
410
  if (def.kind === "Dx") return [def];
410
- const resolved = expr(context, at({ kind: "Opaque", name: def.name }, def));
411
+ const resolved = anonymizeExpr(context, at({ kind: "Opaque", name: def.name }, def));
411
412
  if (resolved.kind !== "Ix") {
412
413
  onWarning({
413
414
  text: `${getLocusPrefix(def.location)}Ignored unexpandable identifier ${JSON.stringify(def.name)} in BY DEF.`,
@@ -426,24 +427,24 @@ export const createAnonymizer = (
426
427
  }),
427
428
  });
428
429
 
429
- const proof = (context: AnonContext, item: Proof): Proof => {
430
+ const anonymizeProof = (context: AnonContext, item: Proof): Proof => {
430
431
  switch (item.kind) {
431
432
  case "Steps": {
432
- const [inner, steps] = mapAccumulate(context, item.steps, step);
433
- const qedProof = proof(
433
+ const [inner, steps] = mapAccumulate(context, item.steps, anonymizeStep);
434
+ const qedProof = anonymizeProof(
434
435
  item.step ? pushWarnedStep(inner, item.step) : inner,
435
436
  item.qed.proof,
436
437
  );
437
438
  return { ...item, steps, qed: { ...item.qed, proof: qedProof } };
438
439
  }
439
440
  case "By":
440
- return { ...item, usable: usable(context, item.usable) };
441
+ return { ...item, usable: anonymizeUsable(context, item.usable) };
441
442
  default:
442
443
  return item;
443
444
  }
444
445
  };
445
446
 
446
- const step = (context: AnonContext, original: Step): [AnonContext, Step] => {
447
+ const anonymizeStep = (context: AnonContext, original: Step): [AnonContext, Step] => {
447
448
  const number: StepNumber | undefined =
448
449
  original.step?.kind === "Unnamed" && isCitable(original)
449
450
  ? {
@@ -457,24 +458,24 @@ export const createAnonymizer = (
457
458
  const item: Step = { ...original, step: number };
458
459
  switch (item.kind) {
459
460
  case "Assert": {
460
- const [, mapped] = sequent(context, item.sequent);
461
+ const [, mapped] = anonymizeSequent(context, item.sequent);
461
462
  const assumptions = mapped.context.reduce(adjoinContext, context);
462
463
  const withTuple = bumpContext(
463
- adjoinStep(bumpContext(assumptions, 1), number, at(tupleForm(mapped), item), item),
464
+ adjoinStep(bumpContext(assumptions, 1), number, at(getTupleForm(mapped), item), item),
464
465
  1,
465
466
  );
466
467
  const inner = mapped.context.length === 0 ? pushWarnedStep(withTuple, number) : withTuple;
467
- const result: Step = { ...item, sequent: mapped, proof: proof(inner, item.proof) };
468
+ const result: Step = { ...item, sequent: mapped, proof: anonymizeProof(inner, item.proof) };
468
469
  return [
469
470
  bumpContext(adjoinStep(context, number, at(exprifySequent(mapped), item), item), 1),
470
471
  result,
471
472
  ];
472
473
  }
473
474
  case "Pcase": {
474
- const expression = expr(context, item.expression);
475
+ const expression = anonymizeExpr(context, item.expression);
475
476
  const tuple = at({ kind: "Tuple", elements: [shiftExpr(2, expression)] }, item);
476
477
  const inner = bumpContext(adjoinStep(bumpContext(context, 2), number, tuple, item), 1);
477
- const result: Step = { ...item, expression, proof: proof(inner, item.proof) };
478
+ const result: Step = { ...item, expression, proof: anonymizeProof(inner, item.proof) };
478
479
  const after = adjoinStep(
479
480
  context,
480
481
  number,
@@ -484,19 +485,19 @@ export const createAnonymizer = (
484
485
  return [bumpContext(after, 1), result];
485
486
  }
486
487
  case "Suffices": {
487
- const [, mapped] = sequent(context, item.sequent);
488
+ const [, mapped] = anonymizeSequent(context, item.sequent);
488
489
  const fact = at({ kind: "Tuple", elements: [at(exprifySequent(mapped), item)] }, item);
489
490
  const inner = bumpContext(adjoinStep(context, number, fact, item), 1);
490
- const result: Step = { ...item, sequent: mapped, proof: proof(inner, item.proof) };
491
+ const result: Step = { ...item, sequent: mapped, proof: anonymizeProof(inner, item.proof) };
491
492
  const assumptions = mapped.context.reduce(adjoinContext, context);
492
- const tuple = at({ kind: "Tuple", elements: [at(tupleForm(mapped), item)] }, item);
493
+ const tuple = at({ kind: "Tuple", elements: [at(getTupleForm(mapped), item)] }, item);
493
494
  return [
494
495
  bumpContext(adjoinStep(bumpContext(assumptions, 1), number, tuple, item), 1),
495
496
  result,
496
497
  ];
497
498
  }
498
499
  case "Have": {
499
- const expression = expr(context, item.expression);
500
+ const expression = anonymizeExpr(context, item.expression);
500
501
  const tuple = at({ kind: "Tuple", elements: [shiftExpr(2, expression)] }, item);
501
502
  return [
502
503
  bumpContext(adjoinStep(bumpContext(context, 2), number, tuple, item), 1),
@@ -504,7 +505,7 @@ export const createAnonymizer = (
504
505
  ];
505
506
  }
506
507
  case "Take": {
507
- const [inner, mapped] = bounds(context, item.bounds);
508
+ const [inner, mapped] = anonymizeBounds(context, item.bounds);
508
509
  const universal = at(
509
510
  { kind: "Quant", quantifier: "Forall", bounds: mapped, body: BAD_EXPRESSION },
510
511
  item,
@@ -515,7 +516,9 @@ export const createAnonymizer = (
515
516
  ];
516
517
  }
517
518
  case "Witness": {
518
- const expressions = item.expressions.map((expression) => expr(context, expression));
519
+ const expressions = item.expressions.map((expression) =>
520
+ anonymizeExpr(context, expression),
521
+ );
519
522
  const tuple = at({ kind: "Tuple", elements: expressions }, item);
520
523
  return [
521
524
  bumpContext(adjoinStep(bumpContext(context, 1), number, tuple, item), 1),
@@ -523,8 +526,8 @@ export const createAnonymizer = (
523
526
  ];
524
527
  }
525
528
  case "Pick": {
526
- const [boundContext, mapped] = bounds(context, item.bounds);
527
- const expression = expr(boundContext, item.expression);
529
+ const [boundContext, mapped] = anonymizeBounds(context, item.bounds);
530
+ const expression = anonymizeExpr(boundContext, item.expression);
528
531
  const existential = at(
529
532
  { kind: "Quant", quantifier: "Exists", bounds: mapped, body: expression },
530
533
  item,
@@ -537,7 +540,7 @@ export const createAnonymizer = (
537
540
  ...item,
538
541
  bounds: mapped,
539
542
  expression,
540
- proof: proof(inner, item.proof),
543
+ proof: anonymizeProof(inner, item.proof),
541
544
  };
542
545
  const declared = adjoinBounds(bumpContext(context, 2), mapped);
543
546
  const shifted = shiftExpr(4 + mapped.length, existential);
@@ -547,13 +550,13 @@ export const createAnonymizer = (
547
550
  ];
548
551
  }
549
552
  case "Use": {
550
- const mapped = usable(context, item.usable);
553
+ const mapped = anonymizeUsable(context, item.usable);
551
554
  return [bumpContext(context, mapped.facts.length), { ...item, usable: mapped }];
552
555
  }
553
556
  case "Hide":
554
- return [context, { ...item, usable: usable(context, item.usable) }];
557
+ return [context, { ...item, usable: anonymizeUsable(context, item.usable) }];
555
558
  case "Define": {
556
- const [inner, definitions] = defns(context, item.definitions);
559
+ const [inner, definitions] = anonymizeDefns(context, item.definitions);
557
560
  return [inner, { ...item, definitions }];
558
561
  }
559
562
  case "Forget":
@@ -562,11 +565,14 @@ export const createAnonymizer = (
562
565
  };
563
566
 
564
567
  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),
568
+ expr: (scope: Scope | undefined, expression: Expr) =>
569
+ anonymizeExpr(getContext(scope), expression),
570
+ defn: (scope: Scope | undefined, definition: Defn) =>
571
+ anonymizeDefn(getContext(scope), definition),
572
+ sequent: (scope: Scope | undefined, item: Sequent) =>
573
+ anonymizeSequent(getContext(scope), item)[1],
574
+ usable: (scope: Scope | undefined, item: Usable) => anonymizeUsable(getContext(scope), item),
575
+ proof: (scope: Scope | undefined, item: Proof) => anonymizeProof(getContext(scope), item),
570
576
  };
571
577
  };
572
578
 
@@ -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