tla-ts 0.0.4-dev.702eb98 → 0.0.4-dev.7714e32

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 (382) hide show
  1. package/README.md +32 -6
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +27 -27
  5. package/dist/deciders.js +34 -34
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +12 -14
  8. package/dist/index.d.ts +12 -14
  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 +516 -25
  15. package/dist/prove.js +518 -27
  16. package/dist/run.cjs +45 -0
  17. package/dist/run.js +45 -0
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +76 -86
  21. package/dist/transfer.js +73 -83
  22. package/dist/worker.cjs +6 -6
  23. package/dist/worker.js +6 -6
  24. package/package.json +1 -1
  25. package/src/ast.ts +2 -2
  26. package/src/bags.ts +22 -23
  27. package/src/builtins.ts +16 -8
  28. package/src/check.ts +131 -1154
  29. package/src/{cli-options.ts → cli/options.ts} +54 -9
  30. package/src/cli/run.ts +63 -0
  31. package/src/cli/shared.ts +106 -0
  32. package/src/cli/tlapm.ts +374 -0
  33. package/src/{run-cli.ts → cli/tlc.ts} +112 -761
  34. package/src/cli/xml-exporter.ts +221 -0
  35. package/src/cli.ts +1 -1
  36. package/src/codegen.ts +17 -15
  37. package/src/config.ts +5 -5
  38. package/src/dependencies.ts +4 -6
  39. package/src/environment.ts +55 -60
  40. package/src/errors.ts +12 -36
  41. package/src/evaluate.ts +81 -101
  42. package/src/exit-codes.ts +1 -1
  43. package/src/fingerprints.ts +3 -3
  44. package/src/index.ts +2 -2
  45. package/src/instances.ts +56 -46
  46. package/src/java-overrides.ts +79 -41
  47. package/src/json.ts +31 -36
  48. package/src/levels.ts +10 -13
  49. package/src/{live-check.ts → liveness-checker.ts} +169 -142
  50. package/src/liveness.ts +38 -34
  51. package/src/obligations/action.ts +58 -105
  52. package/src/obligations/{anon.ts → anonymize.ts} +44 -52
  53. package/src/obligations/equality.ts +260 -0
  54. package/src/obligations/expression.ts +42 -530
  55. package/src/obligations/format.ts +7 -8
  56. package/src/obligations/generate.ts +93 -783
  57. package/src/obligations/index.ts +23 -23
  58. package/src/obligations/levels.ts +38 -44
  59. package/src/obligations/module.ts +106 -729
  60. package/src/obligations/normalize.ts +554 -0
  61. package/src/obligations/operators.ts +176 -0
  62. package/src/obligations/pragma.ts +35 -29
  63. package/src/obligations/printer.ts +98 -209
  64. package/src/obligations/proof.ts +0 -1
  65. package/src/obligations/regroup.ts +100 -0
  66. package/src/obligations/simplify.ts +668 -0
  67. package/src/obligations/source.ts +92 -192
  68. package/src/obligations/{deref.ts → subexpression.ts} +82 -113
  69. package/src/obligations/substitution.ts +261 -0
  70. package/src/obligations/temporal.ts +32 -30
  71. package/src/obligations/tuples.ts +37 -53
  72. package/src/parallel-worker.ts +37 -33
  73. package/src/parallel.ts +30 -24
  74. package/src/parser.ts +67 -74
  75. package/src/{pcal-ast.ts → pcal/ast.ts} +2 -17
  76. package/src/{pcal-parse.ts → pcal/parse.ts} +28 -64
  77. package/src/{pcal-tokenize.ts → pcal/tokenize.ts} +10 -39
  78. package/src/{pcal-translate.ts → pcal/translate.ts} +30 -109
  79. package/src/{pcal-validate.ts → pcal/validate.ts} +10 -20
  80. package/src/{prove → prover}/decide-pool.ts +14 -19
  81. package/src/{prove → prover}/deciders.ts +7 -1
  82. package/src/{obligations/pickle.ts → prover/first-order.ts} +79 -4
  83. package/src/{prove → prover}/isabelle/decide.ts +3 -6
  84. package/src/{prove → prover}/isabelle/encode.ts +106 -138
  85. package/src/{prove → prover}/isabelle/isar/inner-syntax.ts +1 -1
  86. package/src/{prove → prover}/isabelle/isar/method.ts +3 -3
  87. package/src/{prove → prover}/isabelle/isar/type-check.ts +1 -1
  88. package/src/{prove → prover}/isabelle/provers/blast/blast.ts +1 -1
  89. package/src/{prove → prover}/isabelle/provers/blast/branch.ts +1 -1
  90. package/src/{prove → prover}/isabelle/provers/blast/term.ts +3 -4
  91. package/src/{prove → prover}/isabelle/provers/clasimp.ts +1 -1
  92. package/src/{prove → prover}/isabelle/provers/classical.ts +3 -3
  93. package/src/{prove → prover}/isabelle/provers/hypsubst.ts +1 -9
  94. package/src/{prove → prover}/isabelle/pure/conv.ts +1 -1
  95. package/src/{prove → prover}/isabelle/pure/drule.ts +2 -2
  96. package/src/{prove → prover}/isabelle/pure/envir.ts +3 -35
  97. package/src/{prove → prover}/isabelle/pure/logic.ts +4 -76
  98. package/src/{prove → prover}/isabelle/pure/name.ts +1 -13
  99. package/src/{prove → prover}/isabelle/pure/net.ts +2 -49
  100. package/src/{prove → prover}/isabelle/pure/pattern.ts +3 -22
  101. package/src/{prove → prover}/isabelle/pure/raw-simplifier.ts +3 -18
  102. package/src/{prove → prover}/isabelle/pure/seq.ts +0 -23
  103. package/src/{prove → prover}/isabelle/pure/simplifier.ts +2 -8
  104. package/src/{prove → prover}/isabelle/pure/table.ts +1 -8
  105. package/src/{prove → prover}/isabelle/pure/tactic.ts +5 -113
  106. package/src/{prove → prover}/isabelle/pure/tactical.ts +1 -84
  107. package/src/{prove → prover}/isabelle/pure/term-ord.ts +1 -55
  108. package/src/{prove → prover}/isabelle/pure/term.ts +8 -128
  109. package/src/{prove → prover}/isabelle/pure/thm.ts +4 -27
  110. package/src/{prove → prover}/isabelle/pure/type.ts +0 -12
  111. package/src/{prove → prover}/isabelle/pure/unify.ts +1 -1
  112. package/src/{prove → prover}/isabelle/tla/classical-setup.ts +1 -1
  113. package/src/{prove → prover}/ocaml.ts +1 -1
  114. package/src/{prove → prover}/prep/action.ts +54 -66
  115. package/src/{prove → prover}/prep/enabled-axioms.ts +2 -2
  116. package/src/{prove → prover}/prep/fingerprint.ts +3 -3
  117. package/src/{prove → prover}/prep/level-comparison.ts +15 -38
  118. package/src/{prove → prover}/prep/md5.ts +2 -9
  119. package/src/{prove/prep/pragma.ts → prover/prep/methods.ts} +4 -4
  120. package/src/prover/prep/normalize.ts +309 -0
  121. package/src/{prove → prover}/prove-worker.ts +4 -11
  122. package/src/prover/prove.ts +492 -0
  123. package/src/{prove → prover}/ptl/encode.ts +19 -31
  124. package/src/{prove → prover}/smt/axioms.ts +78 -79
  125. package/src/{prove → prover}/smt/data.ts +16 -45
  126. package/src/{prove → prover}/smt/encode.ts +134 -28
  127. package/src/{prove → prover}/smt/extensionality.ts +14 -12
  128. package/src/{prove → prover}/smt/flatten.ts +3 -18
  129. package/src/{prove → prover}/smt/format.ts +14 -3
  130. package/src/{prove → prover}/smt/instances.ts +4 -5
  131. package/src/{prove → prover}/smt/rewrite.ts +41 -59
  132. package/src/{prove → prover}/smt/solver/ast-util.ts +0 -56
  133. package/src/{prove → prover}/smt/solver/case-split-queue.ts +1 -1
  134. package/src/{prove → prover}/smt/solver/enode.ts +1 -1
  135. package/src/{prove → prover}/smt/solver/lp/dep-intervals.ts +0 -14
  136. package/src/{prove → prover}/smt/solver/model-macro-solver.ts +1 -1
  137. package/src/{prove → prover}/smt/solver/nlsat/algebraic.ts +3 -3
  138. package/src/{prove → prover}/smt/solver/nlsat/atoms.ts +1 -1
  139. package/src/{prove → prover}/smt/solver/nlsat/explain.ts +1 -1
  140. package/src/{prove → prover}/smt/solver/nlsat/interval-set.ts +1 -1
  141. package/src/{prove → prover}/smt/solver/nlsat/levelwise.ts +4 -7
  142. package/src/{prove → prover}/smt/solver/nlsat/polynomial.ts +4 -4
  143. package/src/{prove → prover}/smt/solver/nlsat/upolynomial.ts +2 -2
  144. package/src/{prove → prover}/smt/solver/pattern-inference.ts +1 -1
  145. package/src/{prove → prover}/smt/solver/relevancy.ts +2 -2
  146. package/src/{prove → prover}/smt/solver/rewriter.ts +1 -1
  147. package/src/{prove → prover}/smt/solver/solver.ts +2 -2
  148. package/src/prover/tlapm/cache.ts +236 -0
  149. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  150. package/src/{prove → prover}/tlapm/tlapm.ts +1 -2
  151. package/src/prover/verdict.ts +13 -0
  152. package/src/{prove → prover}/zenon/decide.ts +5 -11
  153. package/src/{prove → prover}/zenon/encode.ts +40 -106
  154. package/src/{prove → prover}/zenon/eqrel.ts +1 -1
  155. package/src/{prove → prover}/zenon/equality-rules.ts +1 -1
  156. package/src/{prove → prover}/zenon/expr.ts +2 -2
  157. package/src/{prove → prover}/zenon/index-table.ts +1 -1
  158. package/src/{prove → prover}/zenon/isar.ts +1 -1
  159. package/src/{prove → prover}/zenon/llproof.ts +1 -1
  160. package/src/{prove → prover}/zenon/mltoll.ts +1 -1
  161. package/src/{prove → prover}/zenon/node.ts +1 -1
  162. package/src/{prove → prover}/zenon/search.ts +1 -1
  163. package/src/{prove → prover}/zenon/tla/terms.ts +1 -20
  164. package/src/{prove → prover}/zenon/tla/tla.ts +1 -1
  165. package/src/randomization.ts +19 -24
  166. package/src/resolve.ts +15 -22
  167. package/src/runtime.ts +8 -8
  168. package/src/{sany-builtins.ts → sany/builtins.ts} +1 -1
  169. package/src/{sany-generator.ts → sany/generator.ts} +38 -55
  170. package/src/{sany-levels.ts → sany/levels.ts} +45 -48
  171. package/src/{sany-lexer.ts → sany/lexer.ts} +2 -3
  172. package/src/{sany-linter.ts → sany/linter.ts} +1 -1
  173. package/src/{sany-modules.ts → sany/modules.ts} +2 -2
  174. package/src/{sany-nodes.ts → sany/nodes.ts} +2 -2
  175. package/src/{sany-parse-error.ts → sany/parse-error.ts} +2 -2
  176. package/src/{sany-report.ts → sany/report.ts} +16 -17
  177. package/src/{sany-selectors.ts → sany/selectors.ts} +3 -5
  178. package/src/{sany-source.ts → sany/source.ts} +6 -7
  179. package/src/{sany-xml.ts → sany/xml.ts} +5 -6
  180. package/src/search.ts +969 -0
  181. package/src/spec-description.ts +26 -20
  182. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  183. package/src/standard-modules.ts +16 -20
  184. package/src/state-graph.ts +9 -8
  185. package/src/substitution-levels.ts +2 -2
  186. package/src/successors.ts +16 -19
  187. package/src/symmetry.ts +1 -1
  188. package/src/tableau.ts +6 -7
  189. package/src/tlc/fingerprint.ts +214 -0
  190. package/src/{tlc-messages.ts → tlc/messages.ts} +119 -7
  191. package/src/{tlc-order.ts → tlc/order.ts} +7 -7
  192. package/src/{tlc-random.ts → tlc/random.ts} +3 -213
  193. package/src/{tlc-replay.ts → tlc/replay.ts} +40 -36
  194. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +9 -9
  195. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +30 -25
  196. package/src/transfer.ts +32 -32
  197. package/src/values.ts +72 -67
  198. package/src/worker.ts +1 -4
  199. package/dist/run-cli.cjs +0 -38
  200. package/dist/run-cli.js +0 -38
  201. package/src/canonical.ts +0 -40
  202. package/src/obligations/ctx.ts +0 -64
  203. package/src/prove/prep/defs.ts +0 -27
  204. package/src/prove/prep/elab.ts +0 -156
  205. package/src/prove/prep/enabled.ts +0 -43
  206. package/src/prove/prep/flatten.ts +0 -70
  207. package/src/prove/prep/trivial.ts +0 -22
  208. package/src/prove/prove.ts +0 -417
  209. package/src/prove/smt/axiomatize.ts +0 -69
  210. package/src/prove/smt/simplify.ts +0 -57
  211. package/src/prove/verdict.ts +0 -13
  212. package/src/standard-ranges.ts +0 -116
  213. package/src/value-sources.ts +0 -29
  214. /package/src/{prove → prover}/isabelle/LICENSE +0 -0
  215. /package/src/{prove → prover}/isabelle/LICENSE-tlapm +0 -0
  216. /package/src/{prove → prover}/isabelle/isar/proof.ts +0 -0
  217. /package/src/{prove → prover}/isabelle/isar/statement.ts +0 -0
  218. /package/src/{prove → prover}/isabelle/isar/theory.ts +0 -0
  219. /package/src/{prove → prover}/isabelle/provers/blast/prove.ts +0 -0
  220. /package/src/{prove → prover}/isabelle/provers/blast/rules.ts +0 -0
  221. /package/src/{prove → prover}/isabelle/provers/blast/state.ts +0 -0
  222. /package/src/{prove → prover}/isabelle/pure/bicompose.ts +0 -0
  223. /package/src/{prove → prover}/isabelle/pure/consts.ts +0 -0
  224. /package/src/{prove → prover}/isabelle/pure/goal.ts +0 -0
  225. /package/src/{prove → prover}/isabelle/pure/interrupt.ts +0 -0
  226. /package/src/{prove → prover}/isabelle/pure/list.ts +0 -0
  227. /package/src/{prove → prover}/isabelle/pure/object-logic.ts +0 -0
  228. /package/src/{prove → prover}/isabelle/pure/rewriter.ts +0 -0
  229. /package/src/{prove → prover}/isabelle/pure/search.ts +0 -0
  230. /package/src/{prove → prover}/isabelle/pure/variable.ts +0 -0
  231. /package/src/{prove → prover}/isabelle/tla/context.ts +0 -0
  232. /package/src/{prove → prover}/isabelle/tla/logic-data.ts +0 -0
  233. /package/src/{prove → prover}/isabelle/tla/logic.ts +0 -0
  234. /package/src/{prove → prover}/isabelle/tla/simpdata.ts +0 -0
  235. /package/src/{prove → prover}/isabelle/tools/intuitionistic.ts +0 -0
  236. /package/src/{prove → prover}/ptl/decide.ts +0 -0
  237. /package/src/{prove → prover}/ptl/sat.ts +0 -0
  238. /package/src/{prove → prover}/ptl/tableau.ts +0 -0
  239. /package/src/{prove → prover}/smt/context.ts +0 -0
  240. /package/src/{prove → prover}/smt/solver/act-cache.ts +0 -0
  241. /package/src/{prove → prover}/smt/solver/arith-rewriter.ts +0 -0
  242. /package/src/{prove → prover}/smt/solver/array.ts +0 -0
  243. /package/src/{prove → prover}/smt/solver/asserted-formulas.ts +0 -0
  244. /package/src/{prove → prover}/smt/solver/ast-lt.ts +0 -0
  245. /package/src/{prove → prover}/smt/solver/ast.ts +0 -0
  246. /package/src/{prove → prover}/smt/solver/auf-solver.ts +0 -0
  247. /package/src/{prove → prover}/smt/solver/cg-table.ts +0 -0
  248. /package/src/{prove → prover}/smt/solver/clause.ts +0 -0
  249. /package/src/{prove → prover}/smt/solver/conflict-resolution.ts +0 -0
  250. /package/src/{prove → prover}/smt/solver/context.ts +0 -0
  251. /package/src/{prove → prover}/smt/solver/ctx-simplify.ts +0 -0
  252. /package/src/{prove → prover}/smt/solver/der.ts +0 -0
  253. /package/src/{prove → prover}/smt/solver/dyn-ack.ts +0 -0
  254. /package/src/{prove → prover}/smt/solver/e-matching.ts +0 -0
  255. /package/src/{prove → prover}/smt/solver/expr-ref.ts +0 -0
  256. /package/src/{prove → prover}/smt/solver/expr-safe-replace.ts +0 -0
  257. /package/src/{prove → prover}/smt/solver/fingerprints.ts +0 -0
  258. /package/src/{prove → prover}/smt/solver/flat-literals.ts +0 -0
  259. /package/src/{prove → prover}/smt/solver/goal.ts +0 -0
  260. /package/src/{prove → prover}/smt/solver/hash.ts +0 -0
  261. /package/src/{prove → prover}/smt/solver/hashtable.ts +0 -0
  262. /package/src/{prove → prover}/smt/solver/internalizer.ts +0 -0
  263. /package/src/{prove → prover}/smt/solver/lbool.ts +0 -0
  264. /package/src/{prove → prover}/smt/solver/literal.ts +0 -0
  265. /package/src/{prove → prover}/smt/solver/lp/bound-propagator.ts +0 -0
  266. /package/src/{prove → prover}/smt/solver/lp/constraints.ts +0 -0
  267. /package/src/{prove → prover}/smt/solver/lp/containers.ts +0 -0
  268. /package/src/{prove → prover}/smt/solver/lp/core-solver.ts +0 -0
  269. /package/src/{prove → prover}/smt/solver/lp/cross-nested.ts +0 -0
  270. /package/src/{prove → prover}/smt/solver/lp/dependency.ts +0 -0
  271. /package/src/{prove → prover}/smt/solver/lp/dioph-eq.ts +0 -0
  272. /package/src/{prove → prover}/smt/solver/lp/explanation.ts +0 -0
  273. /package/src/{prove → prover}/smt/solver/lp/gomory.ts +0 -0
  274. /package/src/{prove → prover}/smt/solver/lp/hnf-cutter.ts +0 -0
  275. /package/src/{prove → prover}/smt/solver/lp/hnf.ts +0 -0
  276. /package/src/{prove → prover}/smt/solver/lp/int-cube.ts +0 -0
  277. /package/src/{prove → prover}/smt/solver/lp/int-solver.ts +0 -0
  278. /package/src/{prove → prover}/smt/solver/lp/lar-solver.ts +0 -0
  279. /package/src/{prove → prover}/smt/solver/lp/lar-term.ts +0 -0
  280. /package/src/{prove → prover}/smt/solver/lp/lp-settings.ts +0 -0
  281. /package/src/{prove → prover}/smt/solver/lp/maximize-term.ts +0 -0
  282. /package/src/{prove → prover}/smt/solver/lp/nex-creator.ts +0 -0
  283. /package/src/{prove → prover}/smt/solver/lp/nex.ts +0 -0
  284. /package/src/{prove → prover}/smt/solver/lp/nla-backoff.ts +0 -0
  285. /package/src/{prove → prover}/smt/solver/lp/nla-basics.ts +0 -0
  286. /package/src/{prove → prover}/smt/solver/lp/nla-core.ts +0 -0
  287. /package/src/{prove → prover}/smt/solver/lp/nla-divisions.ts +0 -0
  288. /package/src/{prove → prover}/smt/solver/lp/nla-emonics.ts +0 -0
  289. /package/src/{prove → prover}/smt/solver/lp/nla-factorization.ts +0 -0
  290. /package/src/{prove → prover}/smt/solver/lp/nla-grobner.ts +0 -0
  291. /package/src/{prove → prover}/smt/solver/lp/nla-horner.ts +0 -0
  292. /package/src/{prove → prover}/smt/solver/lp/nla-intervals.ts +0 -0
  293. /package/src/{prove → prover}/smt/solver/lp/nla-monomial-bounds.ts +0 -0
  294. /package/src/{prove → prover}/smt/solver/lp/nla-monotone.ts +0 -0
  295. /package/src/{prove → prover}/smt/solver/lp/nla-order.ts +0 -0
  296. /package/src/{prove → prover}/smt/solver/lp/nla-patcher.ts +0 -0
  297. /package/src/{prove → prover}/smt/solver/lp/nla-tangents.ts +0 -0
  298. /package/src/{prove → prover}/smt/solver/lp/nla-throttle.ts +0 -0
  299. /package/src/{prove → prover}/smt/solver/lp/nla-types.ts +0 -0
  300. /package/src/{prove → prover}/smt/solver/lp/nla-var-eqs.ts +0 -0
  301. /package/src/{prove → prover}/smt/solver/lp/nra-solver.ts +0 -0
  302. /package/src/{prove → prover}/smt/solver/lp/numeric-pair.ts +0 -0
  303. /package/src/{prove → prover}/smt/solver/lp/pdd-interval.ts +0 -0
  304. /package/src/{prove → prover}/smt/solver/lp/pdd-simplifier.ts +0 -0
  305. /package/src/{prove → prover}/smt/solver/lp/pdd-solver.ts +0 -0
  306. /package/src/{prove → prover}/smt/solver/lp/pdd.ts +0 -0
  307. /package/src/{prove → prover}/smt/solver/lp/random-updater.ts +0 -0
  308. /package/src/{prove → prover}/smt/solver/lp/static-matrix.ts +0 -0
  309. /package/src/{prove → prover}/smt/solver/lp/union-find.ts +0 -0
  310. /package/src/{prove → prover}/smt/solver/mam-compiler.ts +0 -0
  311. /package/src/{prove → prover}/smt/solver/mam-interpreter.ts +0 -0
  312. /package/src/{prove → prover}/smt/solver/maximize-ac-sharing.ts +0 -0
  313. /package/src/{prove → prover}/smt/solver/model-checker.ts +0 -0
  314. /package/src/{prove → prover}/smt/solver/model-evaluator.ts +0 -0
  315. /package/src/{prove → prover}/smt/solver/model-finder.ts +0 -0
  316. /package/src/{prove → prover}/smt/solver/model-generator.ts +0 -0
  317. /package/src/{prove → prover}/smt/solver/nlsat/evaluator.ts +0 -0
  318. /package/src/{prove → prover}/smt/solver/nlsat/mpbq.ts +0 -0
  319. /package/src/{prove → prover}/smt/solver/nlsat/solver.ts +0 -0
  320. /package/src/{prove → prover}/smt/solver/nlsat/types.ts +0 -0
  321. /package/src/{prove → prover}/smt/solver/nlsat/upolynomial-factorization.ts +0 -0
  322. /package/src/{prove → prover}/smt/solver/nnf.ts +0 -0
  323. /package/src/{prove → prover}/smt/solver/poly-rewriter.ts +0 -0
  324. /package/src/{prove → prover}/smt/solver/propagate-values.ts +0 -0
  325. /package/src/{prove → prover}/smt/solver/proto-model.ts +0 -0
  326. /package/src/{prove → prover}/smt/solver/pull-quant.ts +0 -0
  327. /package/src/{prove → prover}/smt/solver/qe-lite-der.ts +0 -0
  328. /package/src/{prove → prover}/smt/solver/qe-lite-fm.ts +0 -0
  329. /package/src/{prove → prover}/smt/solver/qe-lite.ts +0 -0
  330. /package/src/{prove → prover}/smt/solver/qi-queue.ts +0 -0
  331. /package/src/{prove → prover}/smt/solver/quant-tactics.ts +0 -0
  332. /package/src/{prove → prover}/smt/solver/quantifier-analyzer.ts +0 -0
  333. /package/src/{prove → prover}/smt/solver/quantifier-manager.ts +0 -0
  334. /package/src/{prove → prover}/smt/solver/random-gen.ts +0 -0
  335. /package/src/{prove → prover}/smt/solver/rational.ts +0 -0
  336. /package/src/{prove → prover}/smt/solver/ref-vector.ts +0 -0
  337. /package/src/{prove → prover}/smt/solver/rewriter-tpl.ts +0 -0
  338. /package/src/{prove → prover}/smt/solver/rlimit.ts +0 -0
  339. /package/src/{prove → prover}/smt/solver/smtlib-parser.ts +0 -0
  340. /package/src/{prove → prover}/smt/solver/sort.ts +0 -0
  341. /package/src/{prove → prover}/smt/solver/sticky-generations.ts +0 -0
  342. /package/src/{prove → prover}/smt/solver/theory-lra-axioms.ts +0 -0
  343. /package/src/{prove → prover}/smt/solver/theory-lra-bounds.ts +0 -0
  344. /package/src/{prove → prover}/smt/solver/theory-lra-final-check.ts +0 -0
  345. /package/src/{prove → prover}/smt/solver/theory-lra-internalize.ts +0 -0
  346. /package/src/{prove → prover}/smt/solver/theory-lra-model.ts +0 -0
  347. /package/src/{prove → prover}/smt/solver/theory-lra-propagate.ts +0 -0
  348. /package/src/{prove → prover}/smt/solver/theory-lra-state.ts +0 -0
  349. /package/src/{prove → prover}/smt/solver/theory-lra.ts +0 -0
  350. /package/src/{prove → prover}/smt/solver/var-subst.ts +0 -0
  351. /package/src/{prove → prover}/smt/solver/z3-license.txt +0 -0
  352. /package/src/{prove → prover}/smt/table.ts +0 -0
  353. /package/src/{prove → prover}/tlaps-module.ts +0 -0
  354. /package/src/{prove → prover}/zenon/LICENSE +0 -0
  355. /package/src/{prove → prover}/zenon/check/check.ts +0 -0
  356. /package/src/{prove → prover}/zenon/check/definitions.ts +0 -0
  357. /package/src/{prove → prover}/zenon/check/equality.ts +0 -0
  358. /package/src/{prove → prover}/zenon/check/functions.ts +0 -0
  359. /package/src/{prove → prover}/zenon/check/keys.ts +0 -0
  360. /package/src/{prove → prover}/zenon/check/propositional.ts +0 -0
  361. /package/src/{prove → prover}/zenon/check/records.ts +0 -0
  362. /package/src/{prove → prover}/zenon/check/relations.ts +0 -0
  363. /package/src/{prove → prover}/zenon/check/rewrites.ts +0 -0
  364. /package/src/{prove → prover}/zenon/check/sets.ts +0 -0
  365. /package/src/{prove → prover}/zenon/check/terms.ts +0 -0
  366. /package/src/{prove → prover}/zenon/check/tla.ts +0 -0
  367. /package/src/{prove → prover}/zenon/isar-case.ts +0 -0
  368. /package/src/{prove → prover}/zenon/limits.ts +0 -0
  369. /package/src/{prove → prover}/zenon/ocaml.ts +0 -0
  370. /package/src/{prove → prover}/zenon/parse.ts +0 -0
  371. /package/src/{prove → prover}/zenon/phrase.ts +0 -0
  372. /package/src/{prove → prover}/zenon/proof.ts +0 -0
  373. /package/src/{prove → prover}/zenon/propositional-rules.ts +0 -0
  374. /package/src/{prove → prover}/zenon/rules.ts +0 -0
  375. /package/src/{prove → prover}/zenon/tla/functions.ts +0 -0
  376. /package/src/{prove → prover}/zenon/tla/llproof.ts +0 -0
  377. /package/src/{prove → prover}/zenon/tla/records.ts +0 -0
  378. /package/src/{prove → prover}/zenon/tla/rewrites.ts +0 -0
  379. /package/src/{prove → prover}/zenon/tla/sets.ts +0 -0
  380. /package/src/{tlc-modules.ts → tlc/jar-data.ts} +0 -0
  381. /package/src/{tlc-summary.ts → tlc/summary.ts} +0 -0
  382. /package/src/{tlc-version.ts → tlc/version.ts} +0 -0
@@ -1,7 +1,5 @@
1
- // tlapm's expression IR (E_t) with de Bruijn indices, and its substitutions (E_subst) and
2
- // alpha-equivalence (E_eq).
1
+ // tlapm's expression IR (E_t) with de Bruijn indices, and the visitors that map over it (Visit).
3
2
 
4
- import { TlaProofError } from "../errors";
5
3
  import type { OldMethod, PragmaSetting } from "./pragma";
6
4
 
7
5
  export interface Locus {
@@ -12,11 +10,13 @@ export interface Locus {
12
10
  endColumn: number;
13
11
  }
14
12
 
15
- export interface ObligationWarning {
13
+ interface ObligationWarning {
16
14
  text: string;
17
15
  channel: "toolbox" | "toolboxOnly" | "stderr" | "stdout";
18
16
  }
19
17
 
18
+ export type Warn = (warning: ObligationWarning) => void;
19
+
20
20
  export const getLocusPosition = (locus: Locus) => {
21
21
  const end = locus.endColumn - 1;
22
22
  if (locus.startLine !== locus.endLine)
@@ -29,8 +29,10 @@ export const getLocusPosition = (locus: Locus) => {
29
29
  export const getLocusText = (locus: Locus) =>
30
30
  `File ${JSON.stringify(locus.file)}, ${getLocusPosition(locus)}`;
31
31
 
32
- export const getAtPrefix = (locus: Locus | undefined) =>
33
- `${locus ? getLocusText(locus) : "<unknown location>"}:\n`;
32
+ export const getLocationText = (locus: Locus | undefined) =>
33
+ locus ? getLocusText(locus) : "<unknown location>";
34
+
35
+ export const getAtPrefix = (locus: Locus | undefined) => `${getLocationText(locus)}:\n`;
34
36
 
35
37
  export const getErrorNote = (locus: Locus | undefined, message: string): ObligationWarning => ({
36
38
  text: `${getAtPrefix(locus)}Error: ${message}`,
@@ -200,7 +202,7 @@ export type ExprCore =
200
202
  | { kind: "At"; isExcept: boolean }
201
203
  | { kind: "Parens"; expression: Expr; form: ParenForm };
202
204
 
203
- interface Field {
205
+ export interface Field {
204
206
  name: string;
205
207
  value: Expr;
206
208
  }
@@ -257,29 +259,6 @@ export interface Sequent {
257
259
  active: Expr;
258
260
  }
259
261
 
260
- export type Substitution =
261
- | { kind: "Shift"; amount: number }
262
- | { kind: "Cons"; expression: Expr; rest: Substitution }
263
- | { kind: "Compose"; outer: Substitution; inner: Substitution }
264
- | { kind: "Bump"; amount: number; rest: Substitution };
265
-
266
- export const shift = (amount: number): Substitution => ({ kind: "Shift", amount });
267
-
268
- export const consSubstitution = (expression: Expr, rest: Substitution): Substitution => ({
269
- kind: "Cons",
270
- expression,
271
- rest,
272
- });
273
-
274
- // Binds the expressions in order, so the last one becomes index 1.
275
- export const consAll = (expressions: Expr[], rest: Substitution) =>
276
- expressions.reduce((inner, expression) => consSubstitution(expression, inner), rest);
277
-
278
- export const bumpBy = (amount: number, substitution: Substitution): Substitution =>
279
- substitution.kind === "Bump"
280
- ? { kind: "Bump", amount: substitution.amount + amount, rest: substitution.rest }
281
- : { kind: "Bump", amount, rest: substitution };
282
-
283
262
  // tlapm's core @@ from, which takes the properties of from.
284
263
  export const at = (core: ExprCore, from: ExprProps): Expr => {
285
264
  const located = from.location ? { ...core, location: from.location } : core;
@@ -298,6 +277,14 @@ export const getHypName = (hyp: Hyp) => {
298
277
  }
299
278
  };
300
279
 
280
+ export const isBuiltinApply = (
281
+ expression: Expr,
282
+ builtin: Builtin,
283
+ ): expression is Extract<Expr, { kind: "Apply" }> =>
284
+ expression.kind === "Apply" &&
285
+ expression.operator.kind === "Internal" &&
286
+ expression.operator.builtin === builtin;
287
+
301
288
  export const applyBuiltin = (builtin: Builtin, args: Expr[], from: ExprProps): Expr =>
302
289
  at({ kind: "Apply", operator: at({ kind: "Internal", builtin }, from), args }, from);
303
290
 
@@ -341,7 +328,6 @@ export const getScopeAt = (scope: Scope | undefined, depth: number) => {
341
328
  return current;
342
329
  };
343
330
 
344
- // Maps the items in order, threading a state from each item to the next.
345
331
  export const mapAccumulate = <State, Item, Result>(
346
332
  state: State,
347
333
  items: Item[],
@@ -412,40 +398,27 @@ export const getBoundedFresh = (name: string, domain: Expr): Hyp => ({
412
398
  domainVisibility: "Visible",
413
399
  });
414
400
 
415
- const applyIndex = (substitution: Substitution, index: number, from: Expr): Expr => {
416
- switch (substitution.kind) {
417
- case "Shift":
418
- return at({ kind: "Ix", index: substitution.amount + index }, from);
419
- case "Cons":
420
- return index === 1
421
- ? at(stripProps(substitution.expression), from)
422
- : applyIndex(substitution.rest, index - 1, from);
423
- case "Compose":
424
- return substituteExpr(substitution.outer, applyIndex(substitution.inner, index, from));
425
- case "Bump":
426
- return index <= substitution.amount
427
- ? at({ kind: "Ix", index }, from)
428
- : substituteExpr(
429
- shift(substitution.amount),
430
- applyIndex(substitution.rest, index - substitution.amount, from),
431
- );
432
- }
433
- };
434
-
435
- export const substituteExprs = (substitution: Substitution, expressions: Expr[]) =>
436
- expressions.map((expression) => substituteExpr(substitution, expression));
437
-
438
- // Beta-reduces a lambda applied to arguments, as E_subst.normalize does.
439
- export const normalizeApply = (operator: Expr, args: Expr[]): ExprCore => {
440
- if (operator.kind === "Lambda") {
441
- if (operator.params.length !== args.length) throw new TlaProofError("Arity mismatch");
442
- return stripProps(substituteExpr(consAll(args, shift(0)), operator.body));
443
- }
444
- if (operator.kind === "Apply") {
445
- return { kind: "Apply", operator: operator.operator, args: [...operator.args, ...args] };
446
- }
447
- return args.length === 0 ? stripProps(operator) : { kind: "Apply", operator, args };
448
- };
401
+ export const getFact = (
402
+ expression: Expr,
403
+ visibility: Visibility,
404
+ time: Time,
405
+ location: Locus | undefined,
406
+ ) => ({ kind: "Fact", expression, visibility, time, location }) satisfies Hyp;
407
+
408
+ // What a quantifier binds each name as, a LAMBDA each parameter, and a LET each definition, as
409
+ // Visit.map does.
410
+ export const getBoundFresh = (bound: Bound) => getFresh(bound.name, bound.level);
411
+
412
+ export const getParamFresh = (param: Param) => getFresh(param.name, "Unknown", param.shape);
413
+
414
+ export const getLocalDefn = (definition: Defn) =>
415
+ ({
416
+ kind: "Defn",
417
+ definition,
418
+ whereDefined: "User",
419
+ visibility: "Visible",
420
+ isLocal: true,
421
+ }) satisfies Hyp;
449
422
 
450
423
  // The node without its properties, as tlapm's e.core.
451
424
  export const stripProps = (expression: Expr): ExprCore => {
@@ -454,460 +427,6 @@ export const stripProps = (expression: Expr): ExprCore => {
454
427
  return core;
455
428
  };
456
429
 
457
- export const substituteBounds = (
458
- substitution: Substitution,
459
- bounds: Bound[],
460
- ): [Substitution, Bound[]] => [
461
- bumpBy(bounds.length, substitution),
462
- mapBoundDomains(bounds, (domain) => substituteExpr(substitution, domain)),
463
- ];
464
-
465
- export const substituteDefn = (substitution: Substitution, definition: Defn): Defn => {
466
- switch (definition.kind) {
467
- case "Recursive":
468
- case "Operator":
469
- case "Bpragma":
470
- return mapDefnBody(definition, (body) => substituteExpr(substitution, body));
471
- case "Instance": {
472
- const inner = bumpBy(definition.instance.args.length, substitution);
473
- return {
474
- ...definition,
475
- instance: {
476
- ...definition.instance,
477
- substitutions: definition.instance.substitutions.map((entry) => ({
478
- name: entry.name,
479
- expression: substituteExpr(inner, entry.expression),
480
- })),
481
- },
482
- };
483
- }
484
- }
485
- };
486
-
487
- export const substituteHyp = (substitution: Substitution, hyp: Hyp): Hyp => {
488
- switch (hyp.kind) {
489
- case "Fresh":
490
- return hyp.domain ? { ...hyp, domain: substituteExpr(substitution, hyp.domain) } : hyp;
491
- case "Flex":
492
- return hyp;
493
- case "Defn":
494
- return { ...hyp, definition: substituteDefn(substitution, hyp.definition) };
495
- case "Fact":
496
- return { ...hyp, expression: substituteExpr(substitution, hyp.expression) };
497
- }
498
- };
499
-
500
- export const substituteSequent = (substitution: Substitution, sequent: Sequent): Sequent => {
501
- const [inner, context] = mapAccumulate(substitution, sequent.context, (current, hyp) => [
502
- bumpBy(1, current),
503
- substituteHyp(current, hyp),
504
- ]);
505
- return { context, active: substituteExpr(inner, sequent.active) };
506
- };
507
-
508
- export const substituteExpr = (substitution: Substitution, expression: Expr): Expr => {
509
- const recurse = (inner: Expr) => substituteExpr(substitution, inner);
510
- switch (expression.kind) {
511
- case "Internal":
512
- case "Opaque":
513
- case "String":
514
- case "Num":
515
- case "At":
516
- return expression;
517
- case "Ix":
518
- return applyIndex(substitution, expression.index, expression);
519
- case "Apply":
520
- return at(
521
- normalizeApply(
522
- recurse(expression.operator),
523
- substituteExprs(substitution, expression.args),
524
- ),
525
- expression,
526
- );
527
- case "Bang":
528
- return {
529
- ...expression,
530
- expression: recurse(expression.expression),
531
- selectors: expression.selectors.map((selector) => mapSelectorArgs(selector, recurse)),
532
- };
533
- case "Lambda":
534
- return {
535
- ...expression,
536
- body: substituteExpr(bumpBy(expression.params.length, substitution), expression.body),
537
- };
538
- case "Let": {
539
- const [inner, definitions] = mapAccumulate(
540
- substitution,
541
- expression.definitions,
542
- (current, definition) => [bumpBy(1, current), substituteDefn(current, definition)],
543
- );
544
- return { ...expression, definitions, body: substituteExpr(inner, expression.body) };
545
- }
546
- case "Sequent":
547
- return { ...expression, sequent: substituteSequent(substitution, expression.sequent) };
548
- case "With":
549
- return { ...expression, expression: recurse(expression.expression) };
550
- case "If":
551
- return {
552
- ...expression,
553
- condition: recurse(expression.condition),
554
- consequent: recurse(expression.consequent),
555
- alternative: recurse(expression.alternative),
556
- };
557
- case "List":
558
- return { ...expression, items: substituteExprs(substitution, expression.items) };
559
- case "Quant": {
560
- const [inner, bounds] = substituteBounds(substitution, expression.bounds);
561
- return { ...expression, bounds, body: substituteExpr(inner, expression.body) };
562
- }
563
- case "Tquant":
564
- return {
565
- ...expression,
566
- body: substituteExpr(bumpBy(expression.names.length, substitution), expression.body),
567
- };
568
- case "Choose":
569
- return {
570
- ...expression,
571
- domain: expression.domain && recurse(expression.domain),
572
- body: substituteExpr(bumpBy(1, substitution), expression.body),
573
- };
574
- case "SetSt":
575
- return {
576
- ...expression,
577
- domain: recurse(expression.domain),
578
- body: substituteExpr(bumpBy(1, substitution), expression.body),
579
- };
580
- case "SetOf": {
581
- const [inner, bounds] = substituteBounds(substitution, expression.bounds);
582
- return { ...expression, bounds, element: substituteExpr(inner, expression.element) };
583
- }
584
- case "SetEnum":
585
- return { ...expression, elements: substituteExprs(substitution, expression.elements) };
586
- case "Arrow":
587
- return {
588
- ...expression,
589
- domain: recurse(expression.domain),
590
- range: recurse(expression.range),
591
- };
592
- case "Fcn": {
593
- const [inner, bounds] = substituteBounds(substitution, expression.bounds);
594
- return { ...expression, bounds, body: substituteExpr(inner, expression.body) };
595
- }
596
- case "FcnApp":
597
- return {
598
- ...expression,
599
- function: recurse(expression.function),
600
- args: substituteExprs(substitution, expression.args),
601
- };
602
- case "Product":
603
- return { ...expression, factors: substituteExprs(substitution, expression.factors) };
604
- case "Tuple":
605
- return { ...expression, elements: substituteExprs(substitution, expression.elements) };
606
- case "Rect":
607
- case "Record":
608
- return {
609
- ...expression,
610
- fields: expression.fields.map((field) => ({
611
- name: field.name,
612
- value: recurse(field.value),
613
- })),
614
- };
615
- case "Except":
616
- return {
617
- ...expression,
618
- function: recurse(expression.function),
619
- specs: mapExceptSpecs(expression.specs, recurse),
620
- };
621
- case "Dot":
622
- return { ...expression, expression: recurse(expression.expression) };
623
- case "Sub":
624
- case "Tsub":
625
- return {
626
- ...expression,
627
- action: recurse(expression.action),
628
- subscript: recurse(expression.subscript),
629
- };
630
- case "Fair":
631
- return {
632
- ...expression,
633
- subscript: recurse(expression.subscript),
634
- action: recurse(expression.action),
635
- };
636
- case "Case":
637
- return {
638
- ...expression,
639
- arms: expression.arms.map((arm) => ({
640
- condition: recurse(arm.condition),
641
- body: recurse(arm.body),
642
- })),
643
- other: expression.other && recurse(expression.other),
644
- };
645
- case "Parens":
646
- return { ...expression, expression: recurse(expression.expression) };
647
- }
648
- };
649
-
650
- export const shiftExpr = (amount: number, expression: Expr) =>
651
- amount === 0 ? expression : substituteExpr(shift(amount), expression);
652
-
653
- const isEqualList = <Item>(
654
- left: Item[],
655
- right: Item[],
656
- isEqual: (left: Item, right: Item) => boolean,
657
- ) => left.length === right.length && left.every((item, index) => isEqual(item, right[index]));
658
-
659
- const isEqualFields = (left: Field[], right: Field[]) => {
660
- const leftMap = new Map(left.map((field) => [field.name, field.value]));
661
- const rightMap = new Map(right.map((field) => [field.name, field.value]));
662
- if (leftMap.size !== rightMap.size) return false;
663
- for (const [name, value] of leftMap) {
664
- const other = rightMap.get(name);
665
- if (!other || !isEqualExpr(value, other)) return false;
666
- }
667
- return true;
668
- };
669
-
670
- const isEqualBound = (left: Bound, right: Bound) =>
671
- left.level === right.level &&
672
- left.domain.kind === right.domain.kind &&
673
- (left.domain.kind !== "Domain" ||
674
- (right.domain.kind === "Domain" &&
675
- isEqualExpr(left.domain.expression, right.domain.expression)));
676
-
677
- const isEqualSelector = (left: Selector, right: Selector) => {
678
- if (left.kind !== right.kind) return false;
679
- switch (left.kind) {
680
- case "Number":
681
- return right.kind === "Number" && left.value === right.value;
682
- case "Instance":
683
- return right.kind === "Instance" && isEqualList(left.args, right.args, isEqualExpr);
684
- case "Label":
685
- return (
686
- right.kind === "Label" &&
687
- left.label === right.label &&
688
- isEqualList(left.args, right.args, isEqualExpr)
689
- );
690
- default:
691
- return true;
692
- }
693
- };
694
-
695
- const isEqualDefn = (left: Defn, right: Defn): boolean => {
696
- if (left.kind === "Operator" && right.kind === "Operator")
697
- return isEqualExpr(left.body, right.body);
698
- if (left.kind === "Bpragma" && right.kind === "Bpragma")
699
- return isEqualExpr(left.body, right.body);
700
- if (left.kind === "Instance" && right.kind === "Instance") {
701
- const leftSubstitutions = left.instance.substitutions.map((entry): Field => ({
702
- name: entry.name,
703
- value: entry.expression,
704
- }));
705
- const rightSubstitutions = right.instance.substitutions.map((entry): Field => ({
706
- name: entry.name,
707
- value: entry.expression,
708
- }));
709
- return (
710
- isEqualList(
711
- left.instance.args,
712
- right.instance.args,
713
- (leftArg, rightArg) => leftArg === rightArg,
714
- ) &&
715
- left.instance.module === right.instance.module &&
716
- isEqualFields(leftSubstitutions, rightSubstitutions)
717
- );
718
- }
719
- return false;
720
- };
721
-
722
- export const isEqualHyp = (left: Hyp, right: Hyp): boolean => {
723
- if (left.kind === "Fresh" && right.kind === "Fresh") {
724
- if (left.level !== right.level || left.shape !== right.shape) return false;
725
- if (!left.domain || !right.domain) return !left.domain && !right.domain;
726
- return isEqualExpr(left.domain, right.domain);
727
- }
728
- if (left.kind === "Flex" && right.kind === "Flex") return true;
729
- if (left.kind === "Defn" && right.kind === "Defn") {
730
- return isEqualDefn(left.definition, right.definition) && left.isLocal === right.isLocal;
731
- }
732
- if (left.kind === "Fact" && right.kind === "Fact") {
733
- return isEqualExpr(left.expression, right.expression);
734
- }
735
- return false;
736
- };
737
-
738
- const isEqualSequent = (left: Sequent, right: Sequent) =>
739
- isEqualList(left.context, right.context, isEqualHyp) && isEqualExpr(left.active, right.active);
740
-
741
- // Alpha-equivalence, including E_eq's quirk of comparing only the first CASE arm.
742
- export const isEqualExpr = (left: Expr, right: Expr): boolean => {
743
- if (left.kind === "Parens") return isEqualExpr(left.expression, right);
744
- if (right.kind === "Parens") return isEqualExpr(left, right.expression);
745
- switch (left.kind) {
746
- case "Ix":
747
- return right.kind === "Ix" && left.index === right.index;
748
- case "Opaque":
749
- return right.kind === "Opaque" && left.name === right.name;
750
- case "Internal":
751
- return right.kind === "Internal" && left.builtin === right.builtin;
752
- case "Lambda":
753
- return (
754
- right.kind === "Lambda" &&
755
- left.params.length === right.params.length &&
756
- isEqualExpr(left.body, right.body)
757
- );
758
- case "Apply":
759
- return (
760
- right.kind === "Apply" &&
761
- isEqualExpr(left.operator, right.operator) &&
762
- isEqualList(left.args, right.args, isEqualExpr)
763
- );
764
- case "Sequent":
765
- return right.kind === "Sequent" && isEqualSequent(left.sequent, right.sequent);
766
- case "Bang":
767
- return (
768
- right.kind === "Bang" &&
769
- isEqualExpr(left.expression, right.expression) &&
770
- isEqualList(left.selectors, right.selectors, isEqualSelector)
771
- );
772
- case "With":
773
- return right.kind === "With" && isEqualExpr(left.expression, right.expression);
774
- case "Let":
775
- return (
776
- right.kind === "Let" &&
777
- isEqualList(left.definitions, right.definitions, isEqualDefn) &&
778
- isEqualExpr(left.body, right.body)
779
- );
780
- case "If":
781
- return (
782
- right.kind === "If" &&
783
- isEqualExpr(left.condition, right.condition) &&
784
- isEqualExpr(left.consequent, right.consequent) &&
785
- isEqualExpr(left.alternative, right.alternative)
786
- );
787
- case "List":
788
- return (
789
- right.kind === "List" &&
790
- left.bullet === right.bullet &&
791
- isEqualList(left.items, right.items, isEqualExpr)
792
- );
793
- case "Quant":
794
- return (
795
- right.kind === "Quant" &&
796
- left.quantifier === right.quantifier &&
797
- isEqualList(left.bounds, right.bounds, isEqualBound) &&
798
- isEqualExpr(left.body, right.body)
799
- );
800
- case "Tquant":
801
- return (
802
- right.kind === "Tquant" &&
803
- left.quantifier === right.quantifier &&
804
- isEqualList(left.names, right.names, (leftName, rightName) => leftName === rightName) &&
805
- isEqualExpr(left.body, right.body)
806
- );
807
- case "Choose":
808
- if (right.kind !== "Choose") return false;
809
- if (left.domain && right.domain) {
810
- return isEqualExpr(left.domain, right.domain) && isEqualExpr(left.body, right.body);
811
- }
812
- return !left.domain && !right.domain && isEqualExpr(left.body, right.body);
813
- case "SetSt":
814
- return (
815
- right.kind === "SetSt" &&
816
- isEqualExpr(left.domain, right.domain) &&
817
- isEqualExpr(left.body, right.body)
818
- );
819
- case "SetOf":
820
- return (
821
- right.kind === "SetOf" &&
822
- isEqualExpr(left.element, right.element) &&
823
- isEqualList(left.bounds, right.bounds, isEqualBound)
824
- );
825
- case "SetEnum":
826
- return right.kind === "SetEnum" && isEqualList(left.elements, right.elements, isEqualExpr);
827
- case "Arrow":
828
- return (
829
- right.kind === "Arrow" &&
830
- isEqualExpr(left.domain, right.domain) &&
831
- isEqualExpr(left.range, right.range)
832
- );
833
- case "Fcn":
834
- return (
835
- right.kind === "Fcn" &&
836
- isEqualList(left.bounds, right.bounds, isEqualBound) &&
837
- isEqualExpr(left.body, right.body)
838
- );
839
- case "FcnApp":
840
- return (
841
- right.kind === "FcnApp" &&
842
- isEqualList([left.function, ...left.args], [right.function, ...right.args], isEqualExpr)
843
- );
844
- case "Tuple":
845
- return right.kind === "Tuple" && isEqualList(left.elements, right.elements, isEqualExpr);
846
- case "Product":
847
- return right.kind === "Product" && isEqualList(left.factors, right.factors, isEqualExpr);
848
- case "Rect":
849
- return right.kind === "Rect" && isEqualFields(left.fields, right.fields);
850
- case "Record":
851
- return right.kind === "Record" && isEqualFields(left.fields, right.fields);
852
- case "Except":
853
- return (
854
- right.kind === "Except" &&
855
- isEqualExpr(left.function, right.function) &&
856
- isEqualList(
857
- left.specs,
858
- right.specs,
859
- (leftSpec, rightSpec) =>
860
- isEqualList(leftSpec.trail, rightSpec.trail, (leftPoint, rightPoint) =>
861
- leftPoint.kind === "Dot"
862
- ? rightPoint.kind === "Dot" && leftPoint.field === rightPoint.field
863
- : rightPoint.kind === "Apply" &&
864
- isEqualExpr(leftPoint.expression, rightPoint.expression),
865
- ) && isEqualExpr(leftSpec.value, rightSpec.value),
866
- )
867
- );
868
- case "Dot":
869
- return (
870
- right.kind === "Dot" &&
871
- isEqualExpr(left.expression, right.expression) &&
872
- left.field === right.field
873
- );
874
- case "Sub":
875
- case "Tsub":
876
- return (
877
- right.kind === left.kind &&
878
- left.modal === right.modal &&
879
- isEqualExpr(left.action, right.action) &&
880
- isEqualExpr(left.subscript, right.subscript)
881
- );
882
- case "Fair":
883
- return (
884
- right.kind === "Fair" &&
885
- left.fairness === right.fairness &&
886
- isEqualExpr(left.subscript, right.subscript) &&
887
- isEqualExpr(left.action, right.action)
888
- );
889
- case "Case": {
890
- if (right.kind !== "Case") return false;
891
- const isArmsEqual =
892
- left.arms.length === 0 || right.arms.length === 0
893
- ? left.arms.length === right.arms.length
894
- : isEqualExpr(left.arms[0].condition, right.arms[0].condition) &&
895
- isEqualExpr(left.arms[0].body, right.arms[0].body);
896
- if (!isArmsEqual) return false;
897
- if (left.other && right.other) return isEqualExpr(left.other, right.other);
898
- return !left.other && !right.other;
899
- }
900
- case "String":
901
- return right.kind === "String" && left.value === right.value;
902
- case "Num":
903
- return (
904
- right.kind === "Num" && left.integer === right.integer && left.fraction === right.fraction
905
- );
906
- case "At":
907
- return right.kind === "At" && left.isExcept === right.isExcept;
908
- }
909
- };
910
-
911
430
  export const mapBoundDomains = (bounds: Bound[], map: (domain: Expr) => Expr): Bound[] =>
912
431
  bounds.map((bound) =>
913
432
  bound.domain.kind === "Domain"
@@ -929,7 +448,7 @@ export const mapExceptSpecs = (specs: ExceptSpec[], map: (inner: Expr) => Expr):
929
448
  return { trail, value };
930
449
  });
931
450
 
932
- const mapDefnBody = (definition: Defn, map: (body: Expr) => Expr): Defn =>
451
+ export const mapDefnBody = (definition: Defn, map: (body: Expr) => Expr): Defn =>
933
452
  definition.kind === "Operator" || definition.kind === "Bpragma"
934
453
  ? { ...definition, body: map(definition.body) }
935
454
  : definition;
@@ -953,7 +472,7 @@ export const mapScoped = <State>(
953
472
  ): Expr => {
954
473
  const recurse = (inner: Expr) => map(state, inner);
955
474
  const bindBounds = (bounds: Bound[]) =>
956
- bounds.reduce((current, bound) => bind(current, getFresh(bound.name, bound.level)), state);
475
+ bounds.reduce((current, bound) => bind(current, getBoundFresh(bound)), state);
957
476
  switch (expression.kind) {
958
477
  case "Ix":
959
478
  case "Internal":
@@ -964,7 +483,7 @@ export const mapScoped = <State>(
964
483
  return expression;
965
484
  case "Lambda": {
966
485
  const inner = expression.params.reduce((current, param) => {
967
- const fresh = getFresh(param.name, "Unknown", param.shape);
486
+ const fresh = getParamFresh(param);
968
487
  return bind(current, param.location ? { ...fresh, location: param.location } : fresh);
969
488
  }, state);
970
489
  return { ...expression, body: map(inner, expression.body) };
@@ -982,14 +501,7 @@ export const mapScoped = <State>(
982
501
  expression.definitions,
983
502
  (current, definition) => {
984
503
  const mapped = mapDefnBody(definition, (body) => map(current, body));
985
- const hyp: Hyp = {
986
- kind: "Defn",
987
- definition: mapped,
988
- whereDefined: "User",
989
- visibility: "Visible",
990
- isLocal: true,
991
- };
992
- return [bind(current, hyp), mapped];
504
+ return [bind(current, getLocalDefn(mapped)), mapped];
993
505
  },
994
506
  );
995
507
  return { ...expression, definitions, body: map(inner, expression.body) };