tla-ts 0.0.4-dev.fa107ef → 0.0.5-dev.cc59f31

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 (378) hide show
  1. package/README.md +37 -126
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +44 -12
  8. package/dist/index.d.ts +44 -12
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +76 -92
  23. package/dist/transfer.js +76 -92
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +21 -12
  27. package/src/ast.ts +2 -2
  28. package/src/bags.ts +22 -23
  29. package/src/builtins.ts +16 -8
  30. package/src/check.ts +131 -1153
  31. package/src/{cli-options.ts → cli/options.ts} +54 -9
  32. package/src/cli/run.ts +63 -0
  33. package/src/cli/shared.ts +106 -0
  34. package/src/cli/tlapm.ts +374 -0
  35. package/src/{run-cli.ts → cli/tlc.ts} +115 -721
  36. package/src/cli/xml-exporter.ts +221 -0
  37. package/src/cli.ts +1 -1
  38. package/src/codegen.ts +43 -22
  39. package/src/config.ts +5 -5
  40. package/src/dependencies.ts +4 -6
  41. package/src/environment.ts +55 -60
  42. package/src/errors.ts +97 -35
  43. package/src/evaluate.ts +135 -120
  44. package/src/exit-codes.ts +1 -1
  45. package/src/fingerprints.ts +3 -3
  46. package/src/index.ts +10 -0
  47. package/src/instances.ts +56 -46
  48. package/src/java-overrides.ts +79 -41
  49. package/src/json.ts +31 -36
  50. package/src/levels.ts +10 -13
  51. package/src/{live-check.ts → liveness-checker.ts} +169 -142
  52. package/src/liveness.ts +38 -34
  53. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  54. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  55. package/src/obligations/equality.ts +260 -0
  56. package/src/obligations/expression.ts +618 -0
  57. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  58. package/src/obligations/generate.ts +457 -0
  59. package/src/{obligations.ts → obligations/index.ts} +46 -32
  60. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  61. package/src/obligations/module.ts +445 -0
  62. package/src/obligations/normalize.ts +554 -0
  63. package/src/obligations/operators.ts +176 -0
  64. package/src/obligations/pragma.ts +195 -0
  65. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  66. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  67. package/src/obligations/regroup.ts +100 -0
  68. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  69. package/src/{obligation-source.ts → obligations/source.ts} +172 -216
  70. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  71. package/src/obligations/substitution.ts +261 -0
  72. package/src/obligations/temporal.ts +321 -0
  73. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  74. package/src/parallel-worker.ts +39 -51
  75. package/src/parallel.ts +39 -66
  76. package/src/parser.ts +67 -74
  77. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  78. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  79. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  80. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  81. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  82. package/src/prover/decide-pool.ts +95 -0
  83. package/src/prover/deciders.ts +33 -0
  84. package/src/prover/first-order.ts +175 -0
  85. package/src/prover/isabelle/LICENSE +36 -0
  86. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  87. package/src/prover/isabelle/decide.ts +44 -0
  88. package/src/prover/isabelle/encode.ts +445 -0
  89. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  90. package/src/prover/isabelle/isar/method.ts +367 -0
  91. package/src/prover/isabelle/isar/proof.ts +28 -0
  92. package/src/prover/isabelle/isar/statement.ts +57 -0
  93. package/src/prover/isabelle/isar/theory.ts +192 -0
  94. package/src/prover/isabelle/isar/type-check.ts +278 -0
  95. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  96. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  97. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  98. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  99. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  100. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  101. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  102. package/src/prover/isabelle/provers/classical.ts +389 -0
  103. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  104. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  105. package/src/prover/isabelle/pure/consts.ts +32 -0
  106. package/src/prover/isabelle/pure/conv.ts +79 -0
  107. package/src/prover/isabelle/pure/drule.ts +264 -0
  108. package/src/prover/isabelle/pure/envir.ts +331 -0
  109. package/src/prover/isabelle/pure/goal.ts +53 -0
  110. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  111. package/src/prover/isabelle/pure/list.ts +12 -0
  112. package/src/prover/isabelle/pure/logic.ts +330 -0
  113. package/src/prover/isabelle/pure/name.ts +98 -0
  114. package/src/prover/isabelle/pure/net.ts +215 -0
  115. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  116. package/src/prover/isabelle/pure/pattern.ts +631 -0
  117. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  118. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  119. package/src/prover/isabelle/pure/search.ts +68 -0
  120. package/src/prover/isabelle/pure/seq.ts +133 -0
  121. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  122. package/src/prover/isabelle/pure/table.ts +201 -0
  123. package/src/prover/isabelle/pure/tactic.ts +168 -0
  124. package/src/prover/isabelle/pure/tactical.ts +264 -0
  125. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  126. package/src/prover/isabelle/pure/term.ts +688 -0
  127. package/src/prover/isabelle/pure/thm.ts +783 -0
  128. package/src/prover/isabelle/pure/type.ts +121 -0
  129. package/src/prover/isabelle/pure/unify.ts +753 -0
  130. package/src/prover/isabelle/pure/variable.ts +25 -0
  131. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  132. package/src/prover/isabelle/tla/context.ts +74 -0
  133. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  134. package/src/prover/isabelle/tla/logic.ts +215 -0
  135. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  136. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  137. package/src/prover/ocaml.ts +22 -0
  138. package/src/prover/prep/action.ts +508 -0
  139. package/src/prover/prep/enabled-axioms.ts +189 -0
  140. package/src/prover/prep/fingerprint.ts +388 -0
  141. package/src/prover/prep/level-comparison.ts +529 -0
  142. package/src/prover/prep/md5.ts +60 -0
  143. package/src/prover/prep/methods.ts +221 -0
  144. package/src/prover/prep/normalize.ts +309 -0
  145. package/src/prover/prove-worker.ts +22 -0
  146. package/src/prover/prove.ts +492 -0
  147. package/src/prover/ptl/decide.ts +68 -0
  148. package/src/prover/ptl/encode.ts +244 -0
  149. package/src/prover/ptl/sat.ts +151 -0
  150. package/src/prover/ptl/tableau.ts +276 -0
  151. package/src/prover/smt/axioms.ts +209 -0
  152. package/src/prover/smt/context.ts +108 -0
  153. package/src/prover/smt/data.ts +636 -0
  154. package/src/prover/smt/encode.ts +275 -0
  155. package/src/prover/smt/extensionality.ts +65 -0
  156. package/src/prover/smt/flatten.ts +112 -0
  157. package/src/prover/smt/format.ts +154 -0
  158. package/src/prover/smt/instances.ts +181 -0
  159. package/src/prover/smt/rewrite.ts +766 -0
  160. package/src/prover/smt/solver/act-cache.ts +265 -0
  161. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  162. package/src/prover/smt/solver/array.ts +22 -0
  163. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  164. package/src/prover/smt/solver/ast-lt.ts +157 -0
  165. package/src/prover/smt/solver/ast-util.ts +91 -0
  166. package/src/prover/smt/solver/ast.ts +1315 -0
  167. package/src/prover/smt/solver/auf-solver.ts +572 -0
  168. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  169. package/src/prover/smt/solver/cg-table.ts +175 -0
  170. package/src/prover/smt/solver/clause.ts +276 -0
  171. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  172. package/src/prover/smt/solver/context.ts +1292 -0
  173. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  174. package/src/prover/smt/solver/der.ts +224 -0
  175. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  176. package/src/prover/smt/solver/e-matching.ts +659 -0
  177. package/src/prover/smt/solver/enode.ts +259 -0
  178. package/src/prover/smt/solver/expr-ref.ts +21 -0
  179. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  180. package/src/prover/smt/solver/fingerprints.ts +92 -0
  181. package/src/prover/smt/solver/flat-literals.ts +51 -0
  182. package/src/prover/smt/solver/goal.ts +138 -0
  183. package/src/prover/smt/solver/hash.ts +173 -0
  184. package/src/prover/smt/solver/hashtable.ts +166 -0
  185. package/src/prover/smt/solver/internalizer.ts +1381 -0
  186. package/src/prover/smt/solver/lbool.ts +5 -0
  187. package/src/prover/smt/solver/literal.ts +24 -0
  188. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  189. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  190. package/src/prover/smt/solver/lp/containers.ts +296 -0
  191. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  192. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  193. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  194. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  195. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  196. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  197. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  198. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  199. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  200. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  201. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  202. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  203. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  204. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  205. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  206. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  207. package/src/prover/smt/solver/lp/nex.ts +120 -0
  208. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  209. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  210. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  211. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  212. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  213. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  214. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  215. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  216. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  217. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  218. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  219. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  220. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  221. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  222. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  223. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  224. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  225. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  226. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  227. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  228. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  229. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  230. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  231. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  232. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  233. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  234. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  235. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  236. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  237. package/src/prover/smt/solver/model-checker.ts +347 -0
  238. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  239. package/src/prover/smt/solver/model-finder.ts +155 -0
  240. package/src/prover/smt/solver/model-generator.ts +97 -0
  241. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  242. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  243. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  244. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  245. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  246. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  247. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  248. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  249. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  250. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  251. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  252. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  253. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  254. package/src/prover/smt/solver/nnf.ts +469 -0
  255. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  256. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  257. package/src/prover/smt/solver/propagate-values.ts +83 -0
  258. package/src/prover/smt/solver/proto-model.ts +551 -0
  259. package/src/prover/smt/solver/pull-quant.ts +139 -0
  260. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  261. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  262. package/src/prover/smt/solver/qe-lite.ts +381 -0
  263. package/src/prover/smt/solver/qi-queue.ts +362 -0
  264. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  265. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  266. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  267. package/src/prover/smt/solver/random-gen.ts +10 -0
  268. package/src/prover/smt/solver/rational.ts +165 -0
  269. package/src/prover/smt/solver/ref-vector.ts +62 -0
  270. package/src/prover/smt/solver/relevancy.ts +247 -0
  271. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  272. package/src/prover/smt/solver/rewriter.ts +843 -0
  273. package/src/prover/smt/solver/rlimit.ts +79 -0
  274. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  275. package/src/prover/smt/solver/solver.ts +71 -0
  276. package/src/prover/smt/solver/sort.ts +35 -0
  277. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  278. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  279. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  280. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  281. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  282. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  283. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  284. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  285. package/src/prover/smt/solver/theory-lra.ts +56 -0
  286. package/src/prover/smt/solver/var-subst.ts +258 -0
  287. package/src/prover/smt/solver/z3-license.txt +10 -0
  288. package/src/prover/smt/table.ts +170 -0
  289. package/src/prover/tlapm/cache.ts +236 -0
  290. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  291. package/src/prover/tlapm/tlapm.ts +96 -0
  292. package/src/prover/tlaps-module.ts +510 -0
  293. package/src/prover/verdict.ts +13 -0
  294. package/src/prover/zenon/LICENSE +32 -0
  295. package/src/prover/zenon/check/check.ts +105 -0
  296. package/src/prover/zenon/check/definitions.ts +144 -0
  297. package/src/prover/zenon/check/equality.ts +182 -0
  298. package/src/prover/zenon/check/functions.ts +62 -0
  299. package/src/prover/zenon/check/keys.ts +125 -0
  300. package/src/prover/zenon/check/propositional.ts +104 -0
  301. package/src/prover/zenon/check/records.ts +188 -0
  302. package/src/prover/zenon/check/relations.ts +121 -0
  303. package/src/prover/zenon/check/rewrites.ts +224 -0
  304. package/src/prover/zenon/check/sets.ts +302 -0
  305. package/src/prover/zenon/check/terms.ts +127 -0
  306. package/src/prover/zenon/check/tla.ts +126 -0
  307. package/src/prover/zenon/decide.ts +107 -0
  308. package/src/prover/zenon/encode.ts +378 -0
  309. package/src/prover/zenon/eqrel.ts +300 -0
  310. package/src/prover/zenon/equality-rules.ts +435 -0
  311. package/src/prover/zenon/expr.ts +551 -0
  312. package/src/prover/zenon/index-table.ts +350 -0
  313. package/src/prover/zenon/isar-case.ts +513 -0
  314. package/src/prover/zenon/isar.ts +1249 -0
  315. package/src/prover/zenon/limits.ts +15 -0
  316. package/src/prover/zenon/llproof.ts +173 -0
  317. package/src/prover/zenon/mltoll.ts +1566 -0
  318. package/src/prover/zenon/node.ts +297 -0
  319. package/src/prover/zenon/ocaml.ts +169 -0
  320. package/src/prover/zenon/parse.ts +247 -0
  321. package/src/prover/zenon/phrase.ts +191 -0
  322. package/src/prover/zenon/proof.ts +198 -0
  323. package/src/prover/zenon/propositional-rules.ts +387 -0
  324. package/src/prover/zenon/rules.ts +94 -0
  325. package/src/prover/zenon/search.ts +288 -0
  326. package/src/prover/zenon/tla/functions.ts +151 -0
  327. package/src/prover/zenon/tla/llproof.ts +480 -0
  328. package/src/prover/zenon/tla/records.ts +225 -0
  329. package/src/prover/zenon/tla/rewrites.ts +447 -0
  330. package/src/prover/zenon/tla/sets.ts +304 -0
  331. package/src/prover/zenon/tla/terms.ts +162 -0
  332. package/src/prover/zenon/tla/tla.ts +506 -0
  333. package/src/randomization.ts +19 -24
  334. package/src/resolve.ts +15 -22
  335. package/src/runtime.ts +8 -8
  336. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  337. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  338. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  339. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  340. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  341. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  342. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  343. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  344. package/src/{sany-report.ts → sany/report.ts} +16 -17
  345. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  346. package/src/{sany-source.ts → sany/source.ts} +6 -7
  347. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  348. package/src/search.ts +969 -0
  349. package/src/spec-description.ts +26 -20
  350. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  351. package/src/standard-modules.ts +21 -22
  352. package/src/state-graph.ts +9 -8
  353. package/src/substitution-levels.ts +2 -2
  354. package/src/successors.ts +38 -22
  355. package/src/symmetry.ts +1 -1
  356. package/src/tableau.ts +6 -7
  357. package/src/tlc/fingerprint.ts +214 -0
  358. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  359. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  360. package/src/{tlc-random.ts → tlc/random.ts} +3 -190
  361. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  362. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  363. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  364. package/src/{tlc-version.ts → tlc/version.ts} +8 -7
  365. package/src/transfer.ts +32 -32
  366. package/src/values.ts +154 -105
  367. package/src/worker.ts +62 -0
  368. package/dist/parallel.cjs +0 -12
  369. package/dist/parallel.js +0 -12
  370. package/dist/run-cli.cjs +0 -55
  371. package/dist/run-cli.js +0 -55
  372. package/src/canonical.ts +0 -40
  373. package/src/obligation-expression.ts +0 -1060
  374. package/src/obligation-module.ts +0 -1042
  375. package/src/standard-ranges.ts +0 -116
  376. package/src/value-sources.ts +0 -29
  377. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  378. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
@@ -1,61 +1,63 @@
1
1
  // A port of tlapm's Expr.Deref: a subexpression reference such as Op!2!<< resolves to the
2
2
  // subexpression it names, abstracted over the bound names it uses.
3
3
 
4
- import { TlaProofError, TlapmBugError } from "./errors";
4
+ import { TlaProofError, TlapmBugError } from "../errors";
5
+ import { consAll, consSubstitution, shift, substituteExpr } from "./substitution";
5
6
  import {
6
7
  at,
7
- consAll,
8
- consSubstitution,
9
8
  getErrorNote,
9
+ getBoundFresh,
10
10
  getChildren,
11
11
  getFresh,
12
+ getParamFresh,
12
13
  mapChildren,
13
14
  mapSelectorArgs,
14
- shift,
15
- substituteExpr,
16
15
  type Bound,
17
16
  type Defn,
18
17
  type Expr,
19
18
  type Hyp,
20
- type ObligationWarning,
19
+ type Warn,
21
20
  type Param,
22
21
  type Selector,
23
- } from "./obligation-expression";
22
+ } from "./expression";
24
23
 
25
- interface Deref {
24
+ interface Resolution {
26
25
  params: Param[];
27
26
  definitions: Defn[];
28
27
  expression: Expr;
29
28
  }
30
29
 
31
- interface Label {
30
+ interface LabelMatch {
32
31
  context: Hyp[];
33
32
  expression: Expr;
34
33
  indices: { name: string; index: number }[];
35
34
  }
36
35
 
37
- const BAD = { kind: "Opaque", name: "$Bad" } satisfies Expr;
36
+ const UNRESOLVED = { kind: "Opaque", name: "$Bad" } satisfies Expr;
38
37
 
39
- const isBad = (expression: Expr) => expression.kind === "Opaque" && expression.name === BAD.name;
38
+ const isUnresolved = (expression: Expr) =>
39
+ expression.kind === "Opaque" && expression.name === UNRESOLVED.name;
40
40
 
41
- const clean = (expression: Expr): Expr => {
41
+ const stripParensAndAtomic = (expression: Expr): Expr => {
42
42
  const mapped =
43
- expression.kind === "Parens" ? clean(expression.expression) : mapChildren(expression, clean);
43
+ expression.kind === "Parens"
44
+ ? stripParensAndAtomic(expression.expression)
45
+ : mapChildren(expression, stripParensAndAtomic);
44
46
  if (!mapped.isAtomic) return mapped;
45
47
  const { isAtomic: _isAtomic, ...rest } = mapped;
46
48
  return rest;
47
49
  };
48
50
 
49
51
  // Parentheses go everywhere but in the definitions of a LET.
50
- const cleanParens = (expression: Expr): Expr => {
52
+ const stripParens = (expression: Expr): Expr => {
51
53
  if (expression.kind === "Let") {
52
54
  return at(
53
- { kind: "Let", definitions: expression.definitions, body: cleanParens(expression.body) },
55
+ { kind: "Let", definitions: expression.definitions, body: stripParens(expression.body) },
54
56
  expression.body,
55
57
  );
56
58
  }
57
- if (expression.kind === "Parens") return cleanParens(expression.expression);
58
- return mapChildren(expression, cleanParens);
59
+ if (expression.kind === "Parens") return stripParens(expression.expression);
60
+ return mapChildren(expression, stripParens);
59
61
  };
60
62
 
61
63
  const hasNegativeIndex = (expression: Expr): boolean =>
@@ -63,14 +65,14 @@ const hasNegativeIndex = (expression: Expr): boolean =>
63
65
 
64
66
  // Visit.iter's context for each binder, stopping at labels with other names and at declarations
65
67
  // in an ASSUME.
66
- const findLabel = (expression: Expr, label: string, context: Hyp[]): Label | undefined => {
68
+ const findLabel = (expression: Expr, label: string, context: Hyp[]): LabelMatch | undefined => {
67
69
  const search = (inner: Expr, innerContext = context) => findLabel(inner, label, innerContext);
68
70
  const searchBounds = (bounds: Bound[], body: Expr) =>
69
- bounds.reduce<Label | undefined>(
71
+ bounds.reduce<LabelMatch | undefined>(
70
72
  (found, bound) =>
71
73
  found ?? (bound.domain.kind === "Domain" ? search(bound.domain.expression) : undefined),
72
74
  undefined,
73
- ) ?? search(body, [...context, ...bounds.map((bound) => getFresh(bound.name, bound.level))]);
75
+ ) ?? search(body, [...context, ...bounds.map(getBoundFresh)]);
74
76
  switch (expression.kind) {
75
77
  case "Parens":
76
78
  if (expression.form.kind !== "Xlabel") return search(expression.expression);
@@ -78,10 +80,7 @@ const findLabel = (expression: Expr, label: string, context: Hyp[]): Label | und
78
80
  ? { context, expression: expression.expression, indices: expression.form.indices }
79
81
  : undefined;
80
82
  case "Lambda":
81
- return search(expression.body, [
82
- ...context,
83
- ...expression.params.map((param) => getFresh(param.name, "Unknown", param.shape)),
84
- ]);
83
+ return search(expression.body, [...context, ...expression.params.map(getParamFresh)]);
85
84
  case "Let": {
86
85
  const inner = [...context];
87
86
  for (const definition of expression.definitions) {
@@ -144,11 +143,7 @@ const getReversal = (count: number, paramCount: number) =>
144
143
  const getIndices = (count: number) =>
145
144
  Array.from({ length: count }, (_item, index): Expr => ({ kind: "Ix", index: count - index }));
146
145
 
147
- const instantiate = (
148
- onWarning: (warning: ObligationWarning) => void,
149
- expression: Expr,
150
- args: Expr[],
151
- ): Expr => {
146
+ const instantiate = (onWarning: Warn, expression: Expr, args: Expr[]): Expr => {
152
147
  switch (expression.kind) {
153
148
  case "Quant":
154
149
  case "Fcn":
@@ -214,11 +209,7 @@ const instantiate = (
214
209
  }
215
210
  };
216
211
 
217
- const abstract = (
218
- onWarning: (warning: ObligationWarning) => void,
219
- definitionCount: number,
220
- expression: Expr,
221
- ): [Param[], Expr] => {
212
+ const abstract = (onWarning: Warn, definitionCount: number, expression: Expr): [Param[], Expr] => {
222
213
  const params = ((): Param[] => {
223
214
  switch (expression.kind) {
224
215
  case "Quant":
@@ -244,8 +235,7 @@ const abstract = (
244
235
  };
245
236
 
246
237
  const getNumbered = (
247
- onWarning: (warning: ObligationWarning) => void,
248
- definitions: Defn[],
238
+ onWarning: Warn,
249
239
  expression: Expr,
250
240
  position: number,
251
241
  origin: Expr,
@@ -260,7 +250,10 @@ const getNumbered = (
260
250
  checkAtMost(items.length);
261
251
  return items[position - 1];
262
252
  };
263
- const result = ((): [Defn[], Expr] => {
253
+ if (expression.kind === "With") {
254
+ return getNumbered(onWarning, expression.expression, position, origin, message);
255
+ }
256
+ const result = ((): Expr => {
264
257
  switch (expression.kind) {
265
258
  case "Sequent": {
266
259
  const sequent = expression.sequent;
@@ -287,102 +280,78 @@ const getNumbered = (
287
280
  { failure: "Expr.Deref.deref_num" },
288
281
  );
289
282
  }
290
- return [definitions, shifted];
283
+ return shifted;
291
284
  }
292
285
  case "Apply":
293
- return [definitions, pick(expression.args)];
294
- case "With":
295
- return getNumbered(
296
- onWarning,
297
- definitions,
298
- expression.expression,
299
- position,
300
- origin,
301
- message,
302
- );
286
+ return pick(expression.args);
303
287
  case "If":
304
- return [
305
- definitions,
306
- pick([expression.condition, expression.consequent, expression.alternative]),
307
- ];
288
+ return pick([expression.condition, expression.consequent, expression.alternative]);
308
289
  case "List":
309
- return [definitions, pick(expression.items)];
290
+ return pick(expression.items);
310
291
  case "SetEnum":
311
292
  case "Tuple":
312
- return [definitions, pick(expression.elements)];
293
+ return pick(expression.elements);
313
294
  case "Product":
314
- return [definitions, pick(expression.factors)];
295
+ return pick(expression.factors);
315
296
  case "Let":
316
297
  checkAtMost(1);
317
- return [[...definitions, ...expression.definitions], expression.body];
298
+ return expression.body;
318
299
  case "Quant":
319
300
  case "SetOf":
320
301
  case "Fcn":
321
- return [
322
- definitions,
323
- pick(
324
- expression.bounds.flatMap((bound) =>
325
- bound.domain.kind === "Domain" ? [bound.domain.expression] : [],
326
- ),
302
+ return pick(
303
+ expression.bounds.flatMap((bound) =>
304
+ bound.domain.kind === "Domain" ? [bound.domain.expression] : [],
327
305
  ),
328
- ];
306
+ );
329
307
  case "Choose":
330
308
  case "SetSt":
331
309
  if (!expression.domain) break;
332
- return [definitions, pick([expression.domain])];
310
+ return pick([expression.domain]);
333
311
  case "Arrow":
334
- return [definitions, pick([expression.domain, expression.range])];
312
+ return pick([expression.domain, expression.range]);
335
313
  case "FcnApp": {
336
314
  const argument =
337
315
  expression.args.length === 1
338
316
  ? expression.args[0]
339
317
  : at({ kind: "Tuple", elements: expression.args }, expression);
340
- return [definitions, pick([expression.function, argument])];
318
+ return pick([expression.function, argument]);
341
319
  }
342
320
  case "Rect":
343
321
  case "Record":
344
- return [definitions, pick(expression.fields.map((field) => field.value))];
322
+ return pick(expression.fields.map((field) => field.value));
345
323
  case "Dot":
346
- return [
347
- definitions,
348
- pick([
349
- expression.expression,
350
- at({ kind: "String", value: expression.field }, expression),
351
- ]),
352
- ];
324
+ return pick([
325
+ expression.expression,
326
+ at({ kind: "String", value: expression.field }, expression),
327
+ ]);
353
328
  case "Except":
354
- return [
355
- definitions,
356
- pick([expression.function, ...expression.specs.map((spec) => spec.value)]),
357
- ];
329
+ return pick([expression.function, ...expression.specs.map((spec) => spec.value)]);
358
330
  case "Sub":
359
331
  case "Tsub":
360
- return [definitions, pick([expression.action, expression.subscript])];
332
+ return pick([expression.action, expression.subscript]);
361
333
  case "Fair":
362
- return [definitions, pick([expression.subscript, expression.action])];
334
+ return pick([expression.subscript, expression.action]);
363
335
  case "Case":
364
- return [
365
- definitions,
366
- pick([
367
- ...expression.arms.map((arm) =>
368
- at({ kind: "Tuple", elements: [arm.condition, arm.body] }, arm.body),
369
- ),
370
- ...(expression.other
371
- ? [at({ kind: "Tuple", elements: [BAD, expression.other] }, expression.other)]
372
- : []),
373
- ]),
374
- ];
336
+ return pick([
337
+ ...expression.arms.map((arm) =>
338
+ at({ kind: "Tuple", elements: [arm.condition, arm.body] }, arm.body),
339
+ ),
340
+ ...(expression.other
341
+ ? [at({ kind: "Tuple", elements: [UNRESOLVED, expression.other] }, expression.other)]
342
+ : []),
343
+ ]);
375
344
  }
376
345
  const emptyMessage = "Expression has no subexpressions";
377
346
  onWarning(getErrorNote(expression.location, emptyMessage));
378
347
  throw new TlaProofError(emptyMessage, { failure: "Expr.Deref.deref_num" });
379
348
  })();
380
- if (isBad(result[1])) {
349
+ if (isUnresolved(result)) {
381
350
  const badMessage = `Cannot resolve subexpression reference !${position}`;
382
351
  onWarning(getErrorNote(expression.location, badMessage));
383
352
  throw new TlaProofError(badMessage, { failure: "Expr.Deref.deref_num" });
384
353
  }
385
- return result;
354
+ return [expression.kind === "Let" ? expression.definitions : [], result];
386
355
  };
387
356
 
388
357
  // Reorders label arguments given in source order to the order of the label's de Bruijn indices.
@@ -397,16 +366,16 @@ const permute = (indices: number[], args: Expr[]) => {
397
366
  };
398
367
 
399
368
  const resolveLabel = (
400
- onWarning: (warning: ObligationWarning) => void,
369
+ onWarning: Warn,
401
370
  definitionCount: number,
402
371
  expression: Expr,
403
372
  label: string,
404
373
  labelArgs: Expr[],
405
- ): Deref => {
374
+ ): Resolution => {
406
375
  const found = findLabel(expression, label, []);
407
376
  if (!found) {
408
377
  onWarning(getErrorNote(expression.location, `Could not find label ${label}`));
409
- return { params: [], definitions: [], expression: BAD };
378
+ return { params: [], definitions: [], expression: UNRESOLVED };
410
379
  }
411
380
  const indices = found.indices;
412
381
  if (indices.length !== labelArgs.length && labelArgs.length > 0) {
@@ -460,12 +429,12 @@ const resolveLabel = (
460
429
  };
461
430
 
462
431
  const resolveLetOperator = (
463
- onWarning: (warning: ObligationWarning) => void,
432
+ onWarning: Warn,
464
433
  definitionCount: number,
465
434
  expression: Expr,
466
435
  label: string,
467
436
  args: Expr[],
468
- ): Deref => {
437
+ ): Resolution => {
469
438
  if (expression.kind !== "Let") {
470
439
  onWarning(getErrorNote(expression.location, `not a LET expression`));
471
440
  throw new TlaProofError("not a LET expression", { failure: "Expr.Deref.deref_letop" });
@@ -516,10 +485,10 @@ const resolveLetOperator = (
516
485
  );
517
486
  };
518
487
 
519
- const deref = (
520
- onWarning: (warning: ObligationWarning) => void,
488
+ const resolveSelectors = (
489
+ onWarning: Warn,
521
490
  isLabel: boolean,
522
- state: Deref,
491
+ state: Resolution,
523
492
  selectors: Selector[],
524
493
  ): Expr => {
525
494
  const [selector, ...rest] = selectors;
@@ -535,19 +504,18 @@ const deref = (
535
504
  state.params.length === 0
536
505
  ? withDefinitions
537
506
  : at({ kind: "Lambda", params: state.params, body: withDefinitions }, withDefinitions);
538
- return { ...clean(abstracted), isAtomic: true };
507
+ return { ...stripParensAndAtomic(abstracted), isAtomic: true };
539
508
  }
540
509
  if (state.expression.isAtomic) {
541
510
  onWarning(getErrorNote(state.expression.location, `Expression has no subexpressions`));
542
- return BAD;
511
+ return UNRESOLVED;
543
512
  }
544
- const expression = isLabel ? state.expression : cleanParens(state.expression);
513
+ const expression = isLabel ? state.expression : stripParens(state.expression);
545
514
  const count = state.definitions.length;
546
- const next = ((): Deref & { rest: Selector[]; isLabel: boolean } => {
515
+ const next = ((): Resolution & { rest: Selector[]; isLabel: boolean } => {
547
516
  const numbered = (position: number, message: string) => {
548
517
  const [definitions, inner] = getNumbered(
549
518
  onWarning,
550
- [],
551
519
  expression,
552
520
  position,
553
521
  state.expression,
@@ -594,7 +562,7 @@ const deref = (
594
562
  }
595
563
  }
596
564
  })();
597
- return deref(
565
+ return resolveSelectors(
598
566
  onWarning,
599
567
  next.isLabel,
600
568
  {
@@ -608,11 +576,7 @@ const deref = (
608
576
  );
609
577
  };
610
578
 
611
- const getInitialDeref = (
612
- onWarning: (warning: ObligationWarning) => void,
613
- operator: Expr,
614
- args: Expr[],
615
- ): Deref => {
579
+ const getInitialResolution = (onWarning: Warn, operator: Expr, args: Expr[]): Resolution => {
616
580
  if (args.length > 0) {
617
581
  return { params: [], definitions: [], expression: instantiate(onWarning, operator, args) };
618
582
  }
@@ -622,13 +586,18 @@ const getInitialDeref = (
622
586
  };
623
587
 
624
588
  export const resolveSubexpression = (
625
- onWarning: (warning: ObligationWarning) => void,
589
+ onWarning: Warn,
626
590
  operator: Expr,
627
591
  args: Expr[],
628
592
  selectors: Selector[],
629
593
  ) => {
630
- const result = deref(onWarning, true, getInitialDeref(onWarning, operator, args), selectors);
631
- if (isBad(result)) {
594
+ const result = resolveSelectors(
595
+ onWarning,
596
+ true,
597
+ getInitialResolution(onWarning, operator, args),
598
+ selectors,
599
+ );
600
+ if (isUnresolved(result)) {
632
601
  const message = "Could not resolve subexpression reference";
633
602
  onWarning(getErrorNote(operator.location, message));
634
603
  throw new TlaProofError(message, { failure: "Expr.Anon: 2" });
@@ -0,0 +1,261 @@
1
+ // tlapm's E_subst: substitutions for de Bruijn indices, applied to every part of an expression.
2
+
3
+ import { TlaProofError } from "../errors";
4
+ import {
5
+ at,
6
+ mapAccumulate,
7
+ mapBoundDomains,
8
+ mapDefnBody,
9
+ mapExceptSpecs,
10
+ mapSelectorArgs,
11
+ stripProps,
12
+ type Bound,
13
+ type Defn,
14
+ type Expr,
15
+ type ExprCore,
16
+ type Hyp,
17
+ type Sequent,
18
+ } from "./expression";
19
+
20
+ export type Substitution =
21
+ | { kind: "Shift"; amount: number }
22
+ | { kind: "Cons"; expression: Expr; rest: Substitution }
23
+ | { kind: "Compose"; outer: Substitution; inner: Substitution }
24
+ | { kind: "Bump"; amount: number; rest: Substitution };
25
+
26
+ export const shift = (amount: number): Substitution => ({ kind: "Shift", amount });
27
+
28
+ export const consSubstitution = (expression: Expr, rest: Substitution): Substitution => ({
29
+ kind: "Cons",
30
+ expression,
31
+ rest,
32
+ });
33
+
34
+ // Binds the expressions in order, so the last one becomes index 1.
35
+ export const consAll = (expressions: Expr[], rest: Substitution) =>
36
+ expressions.reduce((inner, expression) => consSubstitution(expression, inner), rest);
37
+
38
+ export const bumpBy = (amount: number, substitution: Substitution): Substitution =>
39
+ substitution.kind === "Bump"
40
+ ? { kind: "Bump", amount: substitution.amount + amount, rest: substitution.rest }
41
+ : { kind: "Bump", amount, rest: substitution };
42
+
43
+ const applyIndex = (substitution: Substitution, index: number, from: Expr): Expr => {
44
+ switch (substitution.kind) {
45
+ case "Shift":
46
+ return at({ kind: "Ix", index: substitution.amount + index }, from);
47
+ case "Cons":
48
+ return index === 1
49
+ ? at(stripProps(substitution.expression), from)
50
+ : applyIndex(substitution.rest, index - 1, from);
51
+ case "Compose":
52
+ return substituteExpr(substitution.outer, applyIndex(substitution.inner, index, from));
53
+ case "Bump":
54
+ return index <= substitution.amount
55
+ ? at({ kind: "Ix", index }, from)
56
+ : substituteExpr(
57
+ shift(substitution.amount),
58
+ applyIndex(substitution.rest, index - substitution.amount, from),
59
+ );
60
+ }
61
+ };
62
+
63
+ export const substituteExprs = (substitution: Substitution, expressions: Expr[]) =>
64
+ expressions.map((expression) => substituteExpr(substitution, expression));
65
+
66
+ // Beta-reduces a lambda applied to arguments, as E_subst.normalize does.
67
+ export const normalizeApply = (operator: Expr, args: Expr[]): ExprCore => {
68
+ if (operator.kind === "Lambda") {
69
+ if (operator.params.length !== args.length) throw new TlaProofError("Arity mismatch");
70
+ return stripProps(substituteExpr(consAll(args, shift(0)), operator.body));
71
+ }
72
+ if (operator.kind === "Apply") {
73
+ return { kind: "Apply", operator: operator.operator, args: [...operator.args, ...args] };
74
+ }
75
+ return args.length === 0 ? stripProps(operator) : { kind: "Apply", operator, args };
76
+ };
77
+
78
+ export const substituteBounds = (
79
+ substitution: Substitution,
80
+ bounds: Bound[],
81
+ ): [Substitution, Bound[]] => [
82
+ bumpBy(bounds.length, substitution),
83
+ mapBoundDomains(bounds, (domain) => substituteExpr(substitution, domain)),
84
+ ];
85
+
86
+ export const substituteDefn = (substitution: Substitution, definition: Defn): Defn => {
87
+ switch (definition.kind) {
88
+ case "Recursive":
89
+ case "Operator":
90
+ case "Bpragma":
91
+ return mapDefnBody(definition, (body) => substituteExpr(substitution, body));
92
+ case "Instance": {
93
+ const inner = bumpBy(definition.instance.args.length, substitution);
94
+ return {
95
+ ...definition,
96
+ instance: {
97
+ ...definition.instance,
98
+ substitutions: definition.instance.substitutions.map((entry) => ({
99
+ name: entry.name,
100
+ expression: substituteExpr(inner, entry.expression),
101
+ })),
102
+ },
103
+ };
104
+ }
105
+ }
106
+ };
107
+
108
+ export const substituteHyp = (substitution: Substitution, hyp: Hyp): Hyp => {
109
+ switch (hyp.kind) {
110
+ case "Fresh":
111
+ return hyp.domain ? { ...hyp, domain: substituteExpr(substitution, hyp.domain) } : hyp;
112
+ case "Flex":
113
+ return hyp;
114
+ case "Defn":
115
+ return { ...hyp, definition: substituteDefn(substitution, hyp.definition) };
116
+ case "Fact":
117
+ return { ...hyp, expression: substituteExpr(substitution, hyp.expression) };
118
+ }
119
+ };
120
+
121
+ export const substituteSequent = (substitution: Substitution, sequent: Sequent): Sequent => {
122
+ const [inner, context] = mapAccumulate(substitution, sequent.context, (current, hyp) => [
123
+ bumpBy(1, current),
124
+ substituteHyp(current, hyp),
125
+ ]);
126
+ return { context, active: substituteExpr(inner, sequent.active) };
127
+ };
128
+
129
+ export const substituteExpr = (substitution: Substitution, expression: Expr): Expr => {
130
+ const recurse = (inner: Expr) => substituteExpr(substitution, inner);
131
+ switch (expression.kind) {
132
+ case "Internal":
133
+ case "Opaque":
134
+ case "String":
135
+ case "Num":
136
+ case "At":
137
+ return expression;
138
+ case "Ix":
139
+ return applyIndex(substitution, expression.index, expression);
140
+ case "Apply":
141
+ return at(
142
+ normalizeApply(
143
+ recurse(expression.operator),
144
+ substituteExprs(substitution, expression.args),
145
+ ),
146
+ expression,
147
+ );
148
+ case "Bang":
149
+ return {
150
+ ...expression,
151
+ expression: recurse(expression.expression),
152
+ selectors: expression.selectors.map((selector) => mapSelectorArgs(selector, recurse)),
153
+ };
154
+ case "Lambda":
155
+ return {
156
+ ...expression,
157
+ body: substituteExpr(bumpBy(expression.params.length, substitution), expression.body),
158
+ };
159
+ case "Let": {
160
+ const [inner, definitions] = mapAccumulate(
161
+ substitution,
162
+ expression.definitions,
163
+ (current, definition) => [bumpBy(1, current), substituteDefn(current, definition)],
164
+ );
165
+ return { ...expression, definitions, body: substituteExpr(inner, expression.body) };
166
+ }
167
+ case "Sequent":
168
+ return { ...expression, sequent: substituteSequent(substitution, expression.sequent) };
169
+ case "With":
170
+ case "Dot":
171
+ case "Parens":
172
+ return { ...expression, expression: recurse(expression.expression) };
173
+ case "If":
174
+ return {
175
+ ...expression,
176
+ condition: recurse(expression.condition),
177
+ consequent: recurse(expression.consequent),
178
+ alternative: recurse(expression.alternative),
179
+ };
180
+ case "List":
181
+ return { ...expression, items: substituteExprs(substitution, expression.items) };
182
+ case "Quant":
183
+ case "Fcn": {
184
+ const [inner, bounds] = substituteBounds(substitution, expression.bounds);
185
+ return { ...expression, bounds, body: substituteExpr(inner, expression.body) };
186
+ }
187
+ case "Tquant":
188
+ return {
189
+ ...expression,
190
+ body: substituteExpr(bumpBy(expression.names.length, substitution), expression.body),
191
+ };
192
+ case "Choose":
193
+ return {
194
+ ...expression,
195
+ domain: expression.domain && recurse(expression.domain),
196
+ body: substituteExpr(bumpBy(1, substitution), expression.body),
197
+ };
198
+ case "SetSt":
199
+ return {
200
+ ...expression,
201
+ domain: recurse(expression.domain),
202
+ body: substituteExpr(bumpBy(1, substitution), expression.body),
203
+ };
204
+ case "SetOf": {
205
+ const [inner, bounds] = substituteBounds(substitution, expression.bounds);
206
+ return { ...expression, bounds, element: substituteExpr(inner, expression.element) };
207
+ }
208
+ case "SetEnum":
209
+ case "Tuple":
210
+ return { ...expression, elements: substituteExprs(substitution, expression.elements) };
211
+ case "Arrow":
212
+ return {
213
+ ...expression,
214
+ domain: recurse(expression.domain),
215
+ range: recurse(expression.range),
216
+ };
217
+ case "FcnApp":
218
+ return {
219
+ ...expression,
220
+ function: recurse(expression.function),
221
+ args: substituteExprs(substitution, expression.args),
222
+ };
223
+ case "Product":
224
+ return { ...expression, factors: substituteExprs(substitution, expression.factors) };
225
+ case "Rect":
226
+ case "Record":
227
+ return {
228
+ ...expression,
229
+ fields: expression.fields.map((field) => ({
230
+ name: field.name,
231
+ value: recurse(field.value),
232
+ })),
233
+ };
234
+ case "Except":
235
+ return {
236
+ ...expression,
237
+ function: recurse(expression.function),
238
+ specs: mapExceptSpecs(expression.specs, recurse),
239
+ };
240
+ case "Sub":
241
+ case "Tsub":
242
+ case "Fair":
243
+ return {
244
+ ...expression,
245
+ action: recurse(expression.action),
246
+ subscript: recurse(expression.subscript),
247
+ };
248
+ case "Case":
249
+ return {
250
+ ...expression,
251
+ arms: expression.arms.map((arm) => ({
252
+ condition: recurse(arm.condition),
253
+ body: recurse(arm.body),
254
+ })),
255
+ other: expression.other && recurse(expression.other),
256
+ };
257
+ }
258
+ };
259
+
260
+ export const shiftExpr = (amount: number, expression: Expr) =>
261
+ amount === 0 ? expression : substituteExpr(shift(amount), expression);