tla-ts 0.0.3 → 0.0.4-dev.1a3acf6

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 (381) hide show
  1. package/README.md +46 -115
  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 +194 -8
  8. package/dist/index.d.ts +194 -8
  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 +1377 -18
  23. package/dist/transfer.js +1377 -18
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +24 -11
  27. package/src/ast.ts +149 -8
  28. package/src/bags.ts +26 -30
  29. package/src/builtins.ts +45 -19
  30. package/src/bundled-modules.ts +3 -3
  31. package/src/check.ts +1182 -900
  32. package/src/cli/options.ts +109 -0
  33. package/src/cli/run.ts +63 -0
  34. package/src/cli/shared.ts +106 -0
  35. package/src/cli/tlapm.ts +374 -0
  36. package/src/cli/tlc.ts +941 -0
  37. package/src/cli/xml-exporter.ts +221 -0
  38. package/src/cli.ts +9 -2
  39. package/src/codegen.ts +112 -51
  40. package/src/config.ts +254 -181
  41. package/src/dependencies.ts +5 -7
  42. package/src/environment.ts +579 -184
  43. package/src/errors.ts +287 -4
  44. package/src/evaluate.ts +1095 -365
  45. package/src/exit-codes.ts +22 -43
  46. package/src/fingerprints.ts +49 -14
  47. package/src/index.ts +11 -0
  48. package/src/instances.ts +73 -60
  49. package/src/java-overrides.ts +183 -66
  50. package/src/json.ts +31 -36
  51. package/src/levels.ts +197 -54
  52. package/src/lexer.ts +127 -30
  53. package/src/liveness-checker.ts +894 -0
  54. package/src/liveness.ts +246 -596
  55. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  56. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  57. package/src/obligations/equality.ts +260 -0
  58. package/src/obligations/expression.ts +618 -0
  59. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  60. package/src/obligations/generate.ts +457 -0
  61. package/src/{obligations.ts → obligations/index.ts} +46 -32
  62. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  63. package/src/obligations/module.ts +445 -0
  64. package/src/obligations/normalize.ts +554 -0
  65. package/src/obligations/operators.ts +176 -0
  66. package/src/obligations/pragma.ts +195 -0
  67. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  68. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  69. package/src/obligations/regroup.ts +100 -0
  70. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  71. package/src/{obligation-source.ts → obligations/source.ts} +174 -216
  72. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  73. package/src/obligations/substitution.ts +261 -0
  74. package/src/obligations/temporal.ts +321 -0
  75. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  76. package/src/parallel-worker.ts +184 -235
  77. package/src/parallel.ts +156 -91
  78. package/src/parser.ts +490 -188
  79. package/src/pcal/ast.ts +755 -0
  80. package/src/pcal/parse.ts +1487 -0
  81. package/src/pcal/tokenize.ts +487 -0
  82. package/src/pcal/translate.ts +1151 -0
  83. package/src/pcal/validate.ts +444 -0
  84. package/src/prover/decide-pool.ts +95 -0
  85. package/src/prover/deciders.ts +33 -0
  86. package/src/prover/first-order.ts +175 -0
  87. package/src/prover/isabelle/LICENSE +36 -0
  88. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  89. package/src/prover/isabelle/decide.ts +44 -0
  90. package/src/prover/isabelle/encode.ts +445 -0
  91. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  92. package/src/prover/isabelle/isar/method.ts +367 -0
  93. package/src/prover/isabelle/isar/proof.ts +28 -0
  94. package/src/prover/isabelle/isar/statement.ts +57 -0
  95. package/src/prover/isabelle/isar/theory.ts +192 -0
  96. package/src/prover/isabelle/isar/type-check.ts +278 -0
  97. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  98. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  99. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  100. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  101. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  102. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  103. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  104. package/src/prover/isabelle/provers/classical.ts +389 -0
  105. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  106. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  107. package/src/prover/isabelle/pure/consts.ts +32 -0
  108. package/src/prover/isabelle/pure/conv.ts +79 -0
  109. package/src/prover/isabelle/pure/drule.ts +264 -0
  110. package/src/prover/isabelle/pure/envir.ts +331 -0
  111. package/src/prover/isabelle/pure/goal.ts +53 -0
  112. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  113. package/src/prover/isabelle/pure/list.ts +12 -0
  114. package/src/prover/isabelle/pure/logic.ts +330 -0
  115. package/src/prover/isabelle/pure/name.ts +98 -0
  116. package/src/prover/isabelle/pure/net.ts +215 -0
  117. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  118. package/src/prover/isabelle/pure/pattern.ts +631 -0
  119. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  120. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  121. package/src/prover/isabelle/pure/search.ts +68 -0
  122. package/src/prover/isabelle/pure/seq.ts +133 -0
  123. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  124. package/src/prover/isabelle/pure/table.ts +201 -0
  125. package/src/prover/isabelle/pure/tactic.ts +168 -0
  126. package/src/prover/isabelle/pure/tactical.ts +264 -0
  127. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  128. package/src/prover/isabelle/pure/term.ts +688 -0
  129. package/src/prover/isabelle/pure/thm.ts +783 -0
  130. package/src/prover/isabelle/pure/type.ts +121 -0
  131. package/src/prover/isabelle/pure/unify.ts +753 -0
  132. package/src/prover/isabelle/pure/variable.ts +25 -0
  133. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  134. package/src/prover/isabelle/tla/context.ts +74 -0
  135. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  136. package/src/prover/isabelle/tla/logic.ts +215 -0
  137. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  138. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  139. package/src/prover/ocaml.ts +22 -0
  140. package/src/prover/prep/action.ts +508 -0
  141. package/src/prover/prep/enabled-axioms.ts +189 -0
  142. package/src/prover/prep/fingerprint.ts +388 -0
  143. package/src/prover/prep/level-comparison.ts +529 -0
  144. package/src/prover/prep/md5.ts +60 -0
  145. package/src/prover/prep/methods.ts +221 -0
  146. package/src/prover/prep/normalize.ts +309 -0
  147. package/src/prover/prove-worker.ts +22 -0
  148. package/src/prover/prove.ts +492 -0
  149. package/src/prover/ptl/decide.ts +68 -0
  150. package/src/prover/ptl/encode.ts +244 -0
  151. package/src/prover/ptl/sat.ts +151 -0
  152. package/src/prover/ptl/tableau.ts +276 -0
  153. package/src/prover/smt/axioms.ts +209 -0
  154. package/src/prover/smt/context.ts +108 -0
  155. package/src/prover/smt/data.ts +636 -0
  156. package/src/prover/smt/encode.ts +275 -0
  157. package/src/prover/smt/extensionality.ts +65 -0
  158. package/src/prover/smt/flatten.ts +112 -0
  159. package/src/prover/smt/format.ts +154 -0
  160. package/src/prover/smt/instances.ts +181 -0
  161. package/src/prover/smt/rewrite.ts +766 -0
  162. package/src/prover/smt/solver/act-cache.ts +265 -0
  163. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  164. package/src/prover/smt/solver/array.ts +22 -0
  165. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  166. package/src/prover/smt/solver/ast-lt.ts +157 -0
  167. package/src/prover/smt/solver/ast-util.ts +91 -0
  168. package/src/prover/smt/solver/ast.ts +1315 -0
  169. package/src/prover/smt/solver/auf-solver.ts +572 -0
  170. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  171. package/src/prover/smt/solver/cg-table.ts +175 -0
  172. package/src/prover/smt/solver/clause.ts +276 -0
  173. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  174. package/src/prover/smt/solver/context.ts +1292 -0
  175. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  176. package/src/prover/smt/solver/der.ts +224 -0
  177. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  178. package/src/prover/smt/solver/e-matching.ts +659 -0
  179. package/src/prover/smt/solver/enode.ts +259 -0
  180. package/src/prover/smt/solver/expr-ref.ts +21 -0
  181. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  182. package/src/prover/smt/solver/fingerprints.ts +92 -0
  183. package/src/prover/smt/solver/flat-literals.ts +51 -0
  184. package/src/prover/smt/solver/goal.ts +138 -0
  185. package/src/prover/smt/solver/hash.ts +173 -0
  186. package/src/prover/smt/solver/hashtable.ts +166 -0
  187. package/src/prover/smt/solver/internalizer.ts +1381 -0
  188. package/src/prover/smt/solver/lbool.ts +5 -0
  189. package/src/prover/smt/solver/literal.ts +24 -0
  190. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  191. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  192. package/src/prover/smt/solver/lp/containers.ts +296 -0
  193. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  194. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  195. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  196. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  197. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  198. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  199. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  200. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  201. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  202. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  203. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  204. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  205. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  206. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  207. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  208. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  209. package/src/prover/smt/solver/lp/nex.ts +120 -0
  210. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  211. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  212. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  213. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  214. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  215. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  216. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  217. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  218. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  219. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  220. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  221. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  222. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  223. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  224. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  225. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  226. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  227. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  228. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  229. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  230. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  231. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  232. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  233. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  234. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  235. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  236. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  237. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  238. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  239. package/src/prover/smt/solver/model-checker.ts +347 -0
  240. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  241. package/src/prover/smt/solver/model-finder.ts +155 -0
  242. package/src/prover/smt/solver/model-generator.ts +97 -0
  243. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  244. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  245. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  246. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  247. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  248. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  249. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  250. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  251. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  252. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  253. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  254. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  255. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  256. package/src/prover/smt/solver/nnf.ts +469 -0
  257. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  258. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  259. package/src/prover/smt/solver/propagate-values.ts +83 -0
  260. package/src/prover/smt/solver/proto-model.ts +551 -0
  261. package/src/prover/smt/solver/pull-quant.ts +139 -0
  262. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  263. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  264. package/src/prover/smt/solver/qe-lite.ts +381 -0
  265. package/src/prover/smt/solver/qi-queue.ts +362 -0
  266. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  267. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  268. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  269. package/src/prover/smt/solver/random-gen.ts +10 -0
  270. package/src/prover/smt/solver/rational.ts +165 -0
  271. package/src/prover/smt/solver/ref-vector.ts +62 -0
  272. package/src/prover/smt/solver/relevancy.ts +247 -0
  273. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  274. package/src/prover/smt/solver/rewriter.ts +843 -0
  275. package/src/prover/smt/solver/rlimit.ts +79 -0
  276. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  277. package/src/prover/smt/solver/solver.ts +71 -0
  278. package/src/prover/smt/solver/sort.ts +35 -0
  279. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  280. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  281. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  282. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  283. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  284. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  285. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  286. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  287. package/src/prover/smt/solver/theory-lra.ts +56 -0
  288. package/src/prover/smt/solver/var-subst.ts +258 -0
  289. package/src/prover/smt/solver/z3-license.txt +10 -0
  290. package/src/prover/smt/table.ts +170 -0
  291. package/src/prover/tlapm/cache.ts +236 -0
  292. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  293. package/src/prover/tlapm/tlapm.ts +96 -0
  294. package/src/prover/tlaps-module.ts +510 -0
  295. package/src/prover/verdict.ts +13 -0
  296. package/src/prover/zenon/LICENSE +32 -0
  297. package/src/prover/zenon/check/check.ts +105 -0
  298. package/src/prover/zenon/check/definitions.ts +144 -0
  299. package/src/prover/zenon/check/equality.ts +182 -0
  300. package/src/prover/zenon/check/functions.ts +62 -0
  301. package/src/prover/zenon/check/keys.ts +125 -0
  302. package/src/prover/zenon/check/propositional.ts +104 -0
  303. package/src/prover/zenon/check/records.ts +188 -0
  304. package/src/prover/zenon/check/relations.ts +121 -0
  305. package/src/prover/zenon/check/rewrites.ts +224 -0
  306. package/src/prover/zenon/check/sets.ts +302 -0
  307. package/src/prover/zenon/check/terms.ts +127 -0
  308. package/src/prover/zenon/check/tla.ts +126 -0
  309. package/src/prover/zenon/decide.ts +107 -0
  310. package/src/prover/zenon/encode.ts +378 -0
  311. package/src/prover/zenon/eqrel.ts +300 -0
  312. package/src/prover/zenon/equality-rules.ts +435 -0
  313. package/src/prover/zenon/expr.ts +551 -0
  314. package/src/prover/zenon/index-table.ts +350 -0
  315. package/src/prover/zenon/isar-case.ts +513 -0
  316. package/src/prover/zenon/isar.ts +1249 -0
  317. package/src/prover/zenon/limits.ts +15 -0
  318. package/src/prover/zenon/llproof.ts +173 -0
  319. package/src/prover/zenon/mltoll.ts +1566 -0
  320. package/src/prover/zenon/node.ts +297 -0
  321. package/src/prover/zenon/ocaml.ts +169 -0
  322. package/src/prover/zenon/parse.ts +247 -0
  323. package/src/prover/zenon/phrase.ts +191 -0
  324. package/src/prover/zenon/proof.ts +198 -0
  325. package/src/prover/zenon/propositional-rules.ts +387 -0
  326. package/src/prover/zenon/rules.ts +94 -0
  327. package/src/prover/zenon/search.ts +288 -0
  328. package/src/prover/zenon/tla/functions.ts +151 -0
  329. package/src/prover/zenon/tla/llproof.ts +480 -0
  330. package/src/prover/zenon/tla/records.ts +225 -0
  331. package/src/prover/zenon/tla/rewrites.ts +447 -0
  332. package/src/prover/zenon/tla/sets.ts +304 -0
  333. package/src/prover/zenon/tla/terms.ts +162 -0
  334. package/src/prover/zenon/tla/tla.ts +506 -0
  335. package/src/randomization.ts +39 -27
  336. package/src/resolve.ts +1474 -426
  337. package/src/runtime.ts +25 -7
  338. package/src/sany/builtins.ts +147 -0
  339. package/src/sany/generator.ts +3111 -0
  340. package/src/sany/levels.ts +1205 -0
  341. package/src/sany/lexer.ts +544 -0
  342. package/src/sany/linter.ts +122 -0
  343. package/src/sany/modules.ts +1398 -0
  344. package/src/sany/nodes.ts +463 -0
  345. package/src/sany/parse-error.ts +2161 -0
  346. package/src/sany/report.ts +355 -0
  347. package/src/sany/selectors.ts +736 -0
  348. package/src/sany/source.ts +247 -0
  349. package/src/sany/xml.ts +1016 -0
  350. package/src/search.ts +969 -0
  351. package/src/spec-description.ts +66 -29
  352. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  353. package/src/standard-modules.ts +215 -164
  354. package/src/state-graph.ts +181 -0
  355. package/src/subexpressions.ts +231 -171
  356. package/src/substitution-levels.ts +40 -19
  357. package/src/successors.ts +253 -125
  358. package/src/symmetry.ts +194 -54
  359. package/src/tableau.ts +60 -32
  360. package/src/tlc/fingerprint.ts +214 -0
  361. package/src/{tlc-modules.ts → tlc/jar-data.ts} +4 -0
  362. package/src/tlc/messages.ts +441 -0
  363. package/src/{tlc-order.ts → tlc/order.ts} +84 -16
  364. package/src/{tlc-random.ts → tlc/random.ts} +30 -189
  365. package/src/tlc/replay.ts +659 -0
  366. package/src/{tlc-summary.ts → tlc/summary.ts} +20 -5
  367. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +59 -50
  368. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +63 -45
  369. package/src/tlc/version.ts +19 -0
  370. package/src/transfer.ts +44 -32
  371. package/src/values.ts +843 -241
  372. package/src/worker.ts +62 -0
  373. package/dist/parallel.cjs +0 -12
  374. package/dist/parallel.js +0 -12
  375. package/dist/run-cli.cjs +0 -28
  376. package/dist/run-cli.js +0 -28
  377. package/src/canonical.ts +0 -39
  378. package/src/cli-options.ts +0 -58
  379. package/src/obligation-expression.ts +0 -1060
  380. package/src/obligation-module.ts +0 -1042
  381. package/src/run-cli.ts +0 -478
@@ -0,0 +1,688 @@
1
+ // Ported from Isabelle2025's Pure/term.ML. Copyright (c) 1986-2025 University of Cambridge,
2
+ // Technische Universitaet Muenchen, and contributors, see LICENSE.
3
+ //
4
+ // Simply typed lambda terms with de Bruijn indices. Functions that rebuild a term return the
5
+ // very same object when nothing changes, as Isabelle's Same.SAME does, so pointer equality stays a
6
+ // fast path.
7
+ //
8
+ // Unlike Isabelle, applications, abstractions and compound types record what their subterms
9
+ // contain when built: the largest index (maxidx), a bound above every loose bound variable (loose),
10
+ // whether a schematic variable, a beta redex or an eta redex occurs, and a bit for the name of each
11
+ // free variable (flags). A term has every flag of its subterms. Traversals use this to skip
12
+ // subterms they would return unchanged, which gives the same results while touching only the parts
13
+ // that change.
14
+
15
+ import { TlaIsabelleError } from "../../../errors";
16
+
17
+ export type Sort = readonly string[];
18
+
19
+ export type Typ =
20
+ | {
21
+ readonly kind: "Type";
22
+ readonly name: string;
23
+ readonly args: readonly Typ[];
24
+ readonly maxidx: number;
25
+ }
26
+ | { readonly kind: "TFree"; readonly name: string; readonly sort: Sort }
27
+ | { readonly kind: "TVar"; readonly name: string; readonly index: number; readonly sort: Sort };
28
+
29
+ // The fields of every kind of term. A term has all of them, with the ones its kind doesn't use
30
+ // undefined, and the constructors below list them in this order. So all terms share one object
31
+ // layout, and V8 compiles the many switches on kind to monomorphic loads.
32
+ interface TermFields {
33
+ readonly name: string;
34
+ readonly type: Typ;
35
+ readonly index: number;
36
+ readonly body: Term;
37
+ readonly fun: Term;
38
+ readonly arg: Term;
39
+ readonly loose: number;
40
+ readonly maxidx: number;
41
+ readonly flags: number;
42
+ }
43
+
44
+ type TermOf<Kind extends string, Used extends keyof TermFields> = { readonly kind: Kind } & Pick<
45
+ TermFields,
46
+ Used
47
+ > & { readonly [Key in Exclude<keyof TermFields, Used>]: undefined };
48
+
49
+ export type Term =
50
+ | TermOf<"Const", "name" | "type">
51
+ | TermOf<"Free", "name" | "type">
52
+ | TermOf<"Var", "name" | "index" | "type">
53
+ | TermOf<"Bound", "index">
54
+ | TermOf<"Abs", "name" | "type" | "body" | "loose" | "maxidx" | "flags">
55
+ | TermOf<"App", "fun" | "arg" | "loose" | "maxidx" | "flags">;
56
+
57
+ export type Var = Extract<Term, { kind: "Var" }>;
58
+ type Abs = Extract<Term, { kind: "Abs" }>;
59
+ export type App = Extract<Term, { kind: "App" }>;
60
+
61
+ export const HAS_VAR = 1;
62
+ export const HAS_REDEX = 2;
63
+ export const HAS_ETA_REDEX = 4;
64
+
65
+ export const maxidxOfTyp = (type: Typ, maxidx = -1) =>
66
+ Math.max(maxidx, type.kind === "TFree" ? -1 : type.kind === "TVar" ? type.index : type.maxidx);
67
+
68
+ export const maxidxOfTerm = (term: Term, maxidx = -1): number => {
69
+ switch (term.kind) {
70
+ case "Var":
71
+ return Math.max(maxidx, term.index, maxidxOfTyp(term.type));
72
+ case "Const":
73
+ case "Free":
74
+ return maxidxOfTyp(term.type, maxidx);
75
+ case "Bound":
76
+ return maxidx;
77
+ default:
78
+ return Math.max(maxidx, term.maxidx);
79
+ }
80
+ };
81
+
82
+ // The bound on loose bound variables: every one is below it.
83
+ const looseOf = (term: Term) =>
84
+ term.kind === "Bound"
85
+ ? term.index + 1
86
+ : term.kind === "App" || term.kind === "Abs"
87
+ ? term.loose
88
+ : 0;
89
+
90
+ // One of the 28 bits above the others, picked by a cheap hash of the name.
91
+ const freeBit = (name: string) =>
92
+ 8 <<
93
+ ((name.length * 31 + (name.charCodeAt(0) | 0) * 7 + (name.charCodeAt(name.length - 1) | 0)) % 28);
94
+
95
+ export const flagsOf = (term: Term) =>
96
+ term.kind === "Var"
97
+ ? HAS_VAR
98
+ : term.kind === "Free"
99
+ ? freeBit(term.name)
100
+ : term.kind === "App" || term.kind === "Abs"
101
+ ? term.flags
102
+ : 0;
103
+
104
+ // Whether a subterm aconv to pattern could occur in term.
105
+ export const mayOccur = (pattern: Term, term: Term) => (flagsOf(pattern) & ~flagsOf(term)) === 0;
106
+
107
+ export const mkType = (name: string, args: readonly Typ[] = []): Typ => ({
108
+ kind: "Type",
109
+ name,
110
+ args,
111
+ maxidx: args.reduce((result, arg) => maxidxOfTyp(arg, result), -1),
112
+ });
113
+ export const mkTFree = (name: string, sort: Sort = []): Typ => ({ kind: "TFree", name, sort });
114
+ export const mkTVar = (name: string, index: number, sort: Sort = []): Typ => ({
115
+ kind: "TVar",
116
+ name,
117
+ index,
118
+ sort,
119
+ });
120
+
121
+ export const mkConst = (name: string, type: Typ): Term => ({
122
+ kind: "Const",
123
+ name,
124
+ type,
125
+ index: undefined,
126
+ body: undefined,
127
+ fun: undefined,
128
+ arg: undefined,
129
+ loose: undefined,
130
+ maxidx: undefined,
131
+ flags: undefined,
132
+ });
133
+ export const mkFree = (name: string, type: Typ): Term => ({
134
+ kind: "Free",
135
+ name,
136
+ type,
137
+ index: undefined,
138
+ body: undefined,
139
+ fun: undefined,
140
+ arg: undefined,
141
+ loose: undefined,
142
+ maxidx: undefined,
143
+ flags: undefined,
144
+ });
145
+ export const mkVar = (name: string, index: number, type: Typ): Var => ({
146
+ kind: "Var",
147
+ name,
148
+ type,
149
+ index,
150
+ body: undefined,
151
+ fun: undefined,
152
+ arg: undefined,
153
+ loose: undefined,
154
+ maxidx: undefined,
155
+ flags: undefined,
156
+ });
157
+ export const mkBound = (index: number): Term => ({
158
+ kind: "Bound",
159
+ name: undefined,
160
+ type: undefined,
161
+ index,
162
+ body: undefined,
163
+ fun: undefined,
164
+ arg: undefined,
165
+ loose: undefined,
166
+ maxidx: undefined,
167
+ flags: undefined,
168
+ });
169
+ export const mkAbs = (name: string, type: Typ, body: Term): Term => ({
170
+ kind: "Abs",
171
+ name,
172
+ type,
173
+ index: undefined,
174
+ body,
175
+ fun: undefined,
176
+ arg: undefined,
177
+ loose: Math.max(looseOf(body) - 1, 0),
178
+ maxidx: maxidxOfTerm(body, maxidxOfTyp(type)),
179
+ flags:
180
+ flagsOf(body) |
181
+ (body.kind === "App" && body.arg.kind === "Bound" && body.arg.index === 0 ? HAS_ETA_REDEX : 0),
182
+ });
183
+ export const mkApp = (fun: Term, arg: Term): Term => ({
184
+ kind: "App",
185
+ name: undefined,
186
+ type: undefined,
187
+ index: undefined,
188
+ body: undefined,
189
+ fun,
190
+ arg,
191
+ loose: Math.max(looseOf(fun), looseOf(arg)),
192
+ maxidx: maxidxOfTerm(arg, maxidxOfTerm(fun)),
193
+ flags: flagsOf(fun) | flagsOf(arg) | (fun.kind === "Abs" ? HAS_REDEX : 0),
194
+ });
195
+
196
+ export const dummyT = mkType("dummy");
197
+ export const propT = mkType("prop");
198
+
199
+ export const funT = (domain: Typ, range: Typ) => mkType("fun", [domain, range]);
200
+
201
+ // op --->
202
+ export const funTs = (domains: readonly Typ[], range: Typ) =>
203
+ domains.reduceRight((result, domain) => funT(domain, result), range);
204
+
205
+ export const binderTypes = (type: Typ): Typ[] => {
206
+ const types: Typ[] = [];
207
+ let current = type;
208
+ while (current.kind === "Type" && current.name === "fun") {
209
+ types.push(current.args[0]);
210
+ current = current.args[1];
211
+ }
212
+ return types;
213
+ };
214
+
215
+ export const bodyType = (type: Typ): Typ =>
216
+ type.kind === "Type" && type.name === "fun" ? bodyType(type.args[1]) : type;
217
+
218
+ const eqSort = (left: Sort, right: Sort) =>
219
+ left === right ||
220
+ (left.length === right.length && left.every((name, index) => name === right[index]));
221
+
222
+ export const eqTyp = (left: Typ, right: Typ): boolean => {
223
+ if (left === right) return true;
224
+ if (left.kind === "Type")
225
+ return (
226
+ right.kind === "Type" &&
227
+ left.name === right.name &&
228
+ left.args.length === right.args.length &&
229
+ left.args.every((arg, index) => eqTyp(arg, right.args[index]))
230
+ );
231
+ if (left.kind === "TFree")
232
+ return right.kind === "TFree" && left.name === right.name && eqSort(left.sort, right.sort);
233
+ return (
234
+ right.kind === "TVar" &&
235
+ left.name === right.name &&
236
+ left.index === right.index &&
237
+ eqSort(left.sort, right.sort)
238
+ );
239
+ };
240
+
241
+ // fastype_of1: the type of a term, with minimal checking. Types holds the types of the loose
242
+ // bound variables, innermost first.
243
+ export const fastypeOf1 = (types: readonly Typ[], term: Term): Typ => {
244
+ switch (term.kind) {
245
+ case "Const":
246
+ case "Free":
247
+ case "Var":
248
+ return term.type;
249
+ case "Bound": {
250
+ const type = types[term.index];
251
+ if (type === undefined) throw new TlaIsabelleError("TYPE", "fastype_of: Bound");
252
+ return type;
253
+ }
254
+ case "Abs":
255
+ return funT(term.type, fastypeOf1([term.type, ...types], term.body));
256
+ case "App": {
257
+ const type = fastypeOf1(types, term.fun);
258
+ if (type.kind !== "Type" || type.name !== "fun")
259
+ throw new TlaIsabelleError("TYPE", "fastype_of: expected function type");
260
+ return type.args[1];
261
+ }
262
+ }
263
+ };
264
+
265
+ export const fastypeOf = (term: Term) => fastypeOf1([], term);
266
+
267
+ export const listComb = (head: Term, args: readonly Term[]) =>
268
+ args.reduce((result, arg) => mkApp(result, arg), head);
269
+
270
+ export const stripComb = (term: Term): [Term, Term[]] => {
271
+ const args: Term[] = [];
272
+ let current = term;
273
+ while (current.kind === "App") {
274
+ args.push(current.arg);
275
+ current = current.fun;
276
+ }
277
+ return [current, args.reverse()];
278
+ };
279
+
280
+ export const headOf = (term: Term): Term => {
281
+ let current = term;
282
+ while (current.kind === "App") current = current.fun;
283
+ return current;
284
+ };
285
+
286
+ export const stripAbsBody = (term: Term): Term =>
287
+ term.kind === "Abs" ? stripAbsBody(term.body) : term;
288
+
289
+ export const sizeOfTerm = (term: Term): number => {
290
+ switch (term.kind) {
291
+ case "Abs":
292
+ return 1 + sizeOfTerm(term.body);
293
+ case "App":
294
+ return sizeOfTerm(term.fun) + sizeOfTerm(term.arg);
295
+ default:
296
+ return 1;
297
+ }
298
+ };
299
+
300
+ const isAllConst = (term: Term) => term.kind === "Const" && term.name === "Pure.all";
301
+
302
+ export const stripAllBody = (term: Term): Term =>
303
+ term.kind === "App" && isAllConst(term.fun) && term.arg.kind === "Abs"
304
+ ? stripAllBody(term.arg.body)
305
+ : term;
306
+
307
+ export const stripAllVars = (term: Term): { name: string; type: Typ }[] =>
308
+ term.kind === "App" && isAllConst(term.fun) && term.arg.kind === "Abs"
309
+ ? [{ name: term.arg.name, type: term.arg.type }, ...stripAllVars(term.arg.body)]
310
+ : [];
311
+
312
+ // Rebuilds an application, keeping the original object when neither part changed.
313
+ export const updateApp = (term: App, fun: Term, arg: Term): Term =>
314
+ fun === term.fun && arg === term.arg ? term : mkApp(fun, arg);
315
+
316
+ export const updateAbs = (term: Abs, body: Term, type: Typ = term.type): Term =>
317
+ body === term.body && type === term.type ? term : mkAbs(term.name, type, body);
318
+
319
+ // incr_bv: increments the bound variables at or above level by increment.
320
+ const incrBvAt = (increment: number, level: number, term: Term): Term => {
321
+ if (looseOf(term) <= level) return term;
322
+ switch (term.kind) {
323
+ case "Bound":
324
+ return mkBound(term.index + increment);
325
+ case "Abs":
326
+ return updateAbs(term, incrBvAt(increment, level + 1, term.body));
327
+ case "App":
328
+ return updateApp(
329
+ term,
330
+ incrBvAt(increment, level, term.fun),
331
+ incrBvAt(increment, level, term.arg),
332
+ );
333
+ default:
334
+ return term;
335
+ }
336
+ };
337
+
338
+ const incrBv = (increment: number, level: number, term: Term) =>
339
+ increment === 0 ? term : incrBvAt(increment, level, term);
340
+
341
+ export const incrBoundvars = (increment: number, term: Term) => incrBv(increment, 0, term);
342
+
343
+ // loose_bvar: whether term has a loose bound variable at level or beyond.
344
+ const looseBvar = (term: Term, level: number) => looseOf(term) > level;
345
+
346
+ export const looseBvar1 = (term: Term, level: number): boolean => {
347
+ if (looseOf(term) <= level) return false;
348
+ switch (term.kind) {
349
+ case "Bound":
350
+ return term.index === level;
351
+ case "App":
352
+ return looseBvar1(term.fun, level) || looseBvar1(term.arg, level);
353
+ case "Abs":
354
+ return looseBvar1(term.body, level + 1);
355
+ default:
356
+ return false;
357
+ }
358
+ };
359
+
360
+ export const isOpen = (term: Term) => looseBvar(term, 0);
361
+ export const isDependent = (term: Term) => looseBvar1(term, 0);
362
+
363
+ // loose_bnos: the loose bound variables, in Isabelle's insertion order.
364
+ export const looseBnos = (term: Term): number[] => {
365
+ const numbers: number[] = [];
366
+ const add = (current: Term, level: number) => {
367
+ switch (current.kind) {
368
+ case "Bound":
369
+ if (current.index >= level && !numbers.includes(current.index - level))
370
+ numbers.unshift(current.index - level);
371
+ return;
372
+ case "Abs":
373
+ add(current.body, level + 1);
374
+ return;
375
+ case "App":
376
+ add(current.arg, level);
377
+ add(current.fun, level);
378
+ return;
379
+ default:
380
+ return;
381
+ }
382
+ };
383
+ add(term, 0);
384
+ return numbers;
385
+ };
386
+
387
+ // subst_bounds: Bound i becomes args[i]; loose bound variables beyond shift down.
388
+ const substBoundsAt = (args: readonly Term[], level: number, term: Term): Term => {
389
+ if (looseOf(term) <= level) return term;
390
+ switch (term.kind) {
391
+ case "Bound":
392
+ return term.index - level < args.length
393
+ ? incrBoundvars(level, args[term.index - level])
394
+ : mkBound(term.index - args.length);
395
+ case "Abs":
396
+ return updateAbs(term, substBoundsAt(args, level + 1, term.body));
397
+ case "App":
398
+ return updateApp(
399
+ term,
400
+ substBoundsAt(args, level, term.fun),
401
+ substBoundsAt(args, level, term.arg),
402
+ );
403
+ default:
404
+ return term;
405
+ }
406
+ };
407
+
408
+ export const substBounds = (args: readonly Term[], body: Term) =>
409
+ args.length === 0 ? body : substBoundsAt(args, 0, body);
410
+
411
+ export const substBound = (arg: Term, body: Term) => substBounds([arg], body);
412
+
413
+ export const betapply = (fun: Term, arg: Term) =>
414
+ fun.kind === "Abs" ? substBound(arg, fun.body) : mkApp(fun, arg);
415
+
416
+ export const betapplys = (fun: Term, args: readonly Term[]) =>
417
+ args.reduce((result, arg) => betapply(result, arg), fun);
418
+
419
+ export const aconv = (left: Term, right: Term): boolean => {
420
+ if (left === right) return true;
421
+ switch (left.kind) {
422
+ case "App":
423
+ return right.kind === "App" && aconv(left.fun, right.fun) && aconv(left.arg, right.arg);
424
+ case "Abs":
425
+ return right.kind === "Abs" && aconv(left.body, right.body) && eqTyp(left.type, right.type);
426
+ case "Const":
427
+ case "Free":
428
+ return right.kind === left.kind && left.name === right.name && eqTyp(left.type, right.type);
429
+ case "Var":
430
+ return (
431
+ right.kind === "Var" &&
432
+ left.name === right.name &&
433
+ left.index === right.index &&
434
+ eqTyp(left.type, right.type)
435
+ );
436
+ case "Bound":
437
+ return right.kind === "Bound" && left.index === right.index;
438
+ }
439
+ };
440
+
441
+ // Structural equality including the names of abstractions, ML's (op =) on terms.
442
+ export const eqTerm = (left: Term, right: Term): boolean => {
443
+ if (left === right) return true;
444
+ switch (left.kind) {
445
+ case "App":
446
+ return right.kind === "App" && eqTerm(left.fun, right.fun) && eqTerm(left.arg, right.arg);
447
+ case "Abs":
448
+ return (
449
+ right.kind === "Abs" &&
450
+ left.name === right.name &&
451
+ eqTyp(left.type, right.type) &&
452
+ eqTerm(left.body, right.body)
453
+ );
454
+ default:
455
+ return aconv(left, right);
456
+ }
457
+ };
458
+
459
+ // could_unify: a fast filter, false only if the normal terms can't unify.
460
+ const matchRands = (left: Term, right: Term): boolean => {
461
+ let currentLeft = left;
462
+ let currentRight = right;
463
+ while (currentLeft.kind === "App" && currentRight.kind === "App") {
464
+ if (!couldUnify(currentLeft.arg, currentRight.arg)) return false;
465
+ currentLeft = currentLeft.fun;
466
+ currentRight = currentRight.fun;
467
+ }
468
+ return true;
469
+ };
470
+
471
+ export const couldUnify = (left: Term, right: Term): boolean => {
472
+ const leftHead = headOf(left);
473
+ const rightHead = headOf(right);
474
+ if (rightHead.kind === "Var" || leftHead.kind === "Var") return true;
475
+ if (leftHead.kind === "Abs" || rightHead.kind === "Abs") return true;
476
+ if (leftHead.kind === "Const" && rightHead.kind === "Const")
477
+ return leftHead.name === rightHead.name && matchRands(left, right);
478
+ if (leftHead.kind === "Free" && rightHead.kind === "Free")
479
+ return leftHead.name === rightHead.name && matchRands(left, right);
480
+ if (leftHead.kind === "Bound" && rightHead.kind === "Bound")
481
+ return leftHead.index === rightHead.index && matchRands(left, right);
482
+ return false;
483
+ };
484
+
485
+ // abstract_over: replaces the occurrences of pattern with Bound, ready to become an Abs body.
486
+ const abstractAt = (pattern: Term, level: number, term: Term): Term => {
487
+ if (!mayOccur(pattern, term)) return term;
488
+ if (aconv(pattern, term)) return mkBound(level);
489
+ switch (term.kind) {
490
+ case "Abs":
491
+ return updateAbs(term, abstractAt(pattern, level + 1, term.body));
492
+ case "App":
493
+ return updateApp(
494
+ term,
495
+ abstractAt(pattern, level, term.fun),
496
+ abstractAt(pattern, level, term.arg),
497
+ );
498
+ default:
499
+ return term;
500
+ }
501
+ };
502
+
503
+ export const abstractOver = (pattern: Term, body: Term) => abstractAt(pattern, 0, body);
504
+
505
+ const baseName = (name: string) => name.slice(name.lastIndexOf(".") + 1);
506
+
507
+ export const termName = (term: Term) =>
508
+ term.kind === "Const"
509
+ ? baseName(term.name)
510
+ : term.kind === "Free" || term.kind === "Var"
511
+ ? term.name
512
+ : "uu";
513
+
514
+ export const mapTypes = (mapType: (type: Typ) => Typ, term: Term): Term => {
515
+ const visit = (current: Term): Term => {
516
+ switch (current.kind) {
517
+ case "Const":
518
+ case "Free": {
519
+ const type = mapType(current.type);
520
+ return type === current.type ? current : { ...current, type };
521
+ }
522
+ case "Var": {
523
+ const type = mapType(current.type);
524
+ return type === current.type ? current : { ...current, type };
525
+ }
526
+ case "Bound":
527
+ return current;
528
+ case "Abs":
529
+ return updateAbs(current, visit(current.body), mapType(current.type));
530
+ case "App":
531
+ return updateApp(current, visit(current.fun), visit(current.arg));
532
+ }
533
+ };
534
+ return visit(term);
535
+ };
536
+
537
+ export const mapAtyps = (mapAtyp: (type: Typ) => Typ, type: Typ): Typ => {
538
+ if (type.kind !== "Type") return mapAtyp(type);
539
+ const args = type.args.map((arg) => mapAtyps(mapAtyp, arg));
540
+ return args.every((arg, index) => arg === type.args[index]) ? type : mkType(type.name, args);
541
+ };
542
+
543
+ const foldAterms = <State>(
544
+ visit: (term: Term, state: State) => State,
545
+ term: Term,
546
+ state: State,
547
+ ): State => {
548
+ switch (term.kind) {
549
+ case "App":
550
+ return foldAterms(visit, term.arg, foldAterms(visit, term.fun, state));
551
+ case "Abs":
552
+ return foldAterms(visit, term.body, state);
553
+ default:
554
+ return visit(term, state);
555
+ }
556
+ };
557
+
558
+ // fold_aterms over the schematic variables only, skipping the subterms without one.
559
+ export const foldVars = <State>(
560
+ visit: (variable: Var, state: State) => State,
561
+ term: Term,
562
+ state: State,
563
+ ): State => {
564
+ if ((flagsOf(term) & HAS_VAR) === 0) return state;
565
+ switch (term.kind) {
566
+ case "App":
567
+ return foldVars(visit, term.arg, foldVars(visit, term.fun, state));
568
+ case "Abs":
569
+ return foldVars(visit, term.body, state);
570
+ case "Var":
571
+ return visit(term, state);
572
+ default:
573
+ return state;
574
+ }
575
+ };
576
+
577
+ export const foldAtyps = <State>(
578
+ visit: (type: Typ, state: State) => State,
579
+ type: Typ,
580
+ state: State,
581
+ ): State =>
582
+ type.kind === "Type"
583
+ ? type.args.reduce((result, arg) => foldAtyps(visit, arg, result), state)
584
+ : visit(type, state);
585
+
586
+ export const foldTypes = <State>(
587
+ visit: (type: Typ, state: State) => State,
588
+ term: Term,
589
+ state: State,
590
+ ): State => {
591
+ switch (term.kind) {
592
+ case "Const":
593
+ case "Free":
594
+ case "Var":
595
+ return visit(term.type, state);
596
+ case "Bound":
597
+ return state;
598
+ case "Abs":
599
+ return foldTypes(visit, term.body, visit(term.type, state));
600
+ case "App":
601
+ return foldTypes(visit, term.arg, foldTypes(visit, term.fun, state));
602
+ }
603
+ };
604
+
605
+ export const existsSubterm = (predicate: (term: Term) => boolean, term: Term): boolean => {
606
+ if (predicate(term)) return true;
607
+ if (term.kind === "App")
608
+ return existsSubterm(predicate, term.fun) || existsSubterm(predicate, term.arg);
609
+ if (term.kind === "Abs") return existsSubterm(predicate, term.body);
610
+ return false;
611
+ };
612
+
613
+ export const existsType = (predicate: (type: Typ) => boolean, term: Term): boolean => {
614
+ switch (term.kind) {
615
+ case "Const":
616
+ case "Free":
617
+ case "Var":
618
+ return predicate(term.type);
619
+ case "Bound":
620
+ return false;
621
+ case "Abs":
622
+ return predicate(term.type) || existsType(predicate, term.body);
623
+ case "App":
624
+ return existsType(predicate, term.fun) || existsType(predicate, term.arg);
625
+ }
626
+ };
627
+
628
+ const sameVar = (left: Var, right: Var) =>
629
+ left.name === right.name && left.index === right.index && eqTyp(left.type, right.type);
630
+
631
+ // add_vars: the schematic variables, latest first, as Isabelle's insert builds the list.
632
+ export const addVars = (term: Term, vars: Var[]): Var[] =>
633
+ foldVars(
634
+ (current, result: Var[]) =>
635
+ !result.some((other) => sameVar(other, current)) ? [current, ...result] : result,
636
+ term,
637
+ vars,
638
+ );
639
+
640
+ export const addFreeNames = (term: Term, names: string[]): string[] =>
641
+ foldAterms(
642
+ (current, result: string[]) =>
643
+ current.kind === "Free" && !result.includes(current.name)
644
+ ? [current.name, ...result]
645
+ : result,
646
+ term,
647
+ names,
648
+ );
649
+
650
+ // match_bvs: the pairs of corresponding abstraction names while two terms look alike.
651
+ const matchBvs = (left: Term, right: Term, pairs: [string, string][]): [string, string][] => {
652
+ if (left.kind === "Abs" && right.kind === "Abs") {
653
+ const added: [string, string][] =
654
+ left.name !== "" && right.name !== "" ? [[left.name, right.name], ...pairs] : pairs;
655
+ return matchBvs(left.body, right.body, added);
656
+ }
657
+ if (left.kind === "App" && right.kind === "App")
658
+ return matchBvs(left.fun, right.fun, matchBvs(left.arg, right.arg, pairs));
659
+ return pairs;
660
+ };
661
+
662
+ export const matchBvars = (left: Term, right: Term, pairs: [string, string][]) =>
663
+ matchBvs(stripAbsBody(left), stripAbsBody(right), pairs);
664
+
665
+ const mapAbsVars = (rename: (name: string) => string, term: Term): Term => {
666
+ switch (term.kind) {
667
+ case "Abs": {
668
+ const name = rename(term.name);
669
+ const body = mapAbsVars(rename, term.body);
670
+ return name === term.name ? updateAbs(term, body) : mkAbs(name, term.type, body);
671
+ }
672
+ case "App":
673
+ return updateApp(term, mapAbsVars(rename, term.fun), mapAbsVars(rename, term.arg));
674
+ default:
675
+ return term;
676
+ }
677
+ };
678
+
679
+ // rename_abs: renames the abstractions of term after those of obj where pat matches obj.
680
+ export const renameAbs = (pattern: Term, object: Term, term: Term): Term | undefined => {
681
+ const renaming = new Map<string, string>();
682
+ matchBvs(pattern, object, []).forEach(([from, to]) => {
683
+ if (!renaming.has(from)) renaming.set(from, to);
684
+ });
685
+ if ([...renaming].every(([from, to]) => from === to)) return undefined;
686
+ const renamed = mapAbsVars((name) => renaming.get(name) ?? name, term);
687
+ return renamed === term ? undefined : renamed;
688
+ };