tla-ts 0.0.9 → 0.0.10-dev.63a6693bd

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (400) hide show
  1. package/README.md +29 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +29 -29
  5. package/dist/deciders.js +42 -42
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +106 -10
  8. package/dist/index.d.ts +106 -10
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +117 -37
  15. package/dist/prove.js +116 -36
  16. package/dist/run.cjs +143 -31
  17. package/dist/run.js +143 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +129 -104
  21. package/dist/transfer.js +129 -104
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +3 -1
  25. package/src/ast.ts +48 -62
  26. package/src/bags.ts +99 -102
  27. package/src/builtins.ts +28 -75
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check-failure.ts +116 -0
  30. package/src/check-trace.ts +282 -0
  31. package/src/check.ts +599 -754
  32. package/src/cli/options.ts +12 -32
  33. package/src/cli/run.ts +0 -2
  34. package/src/cli/runtime-invariants.ts +136 -0
  35. package/src/cli/shared.ts +19 -12
  36. package/src/cli/tlapm.ts +14 -25
  37. package/src/cli/tlc-arguments.ts +652 -0
  38. package/src/cli/tlc-output.ts +687 -0
  39. package/src/cli/tlc-usage.ts +361 -0
  40. package/src/cli/tlc.ts +309 -658
  41. package/src/cli/typescript.ts +23 -0
  42. package/src/cli/xml-exporter.ts +27 -49
  43. package/src/cli.ts +0 -1
  44. package/src/codegen.ts +196 -74
  45. package/src/config.ts +140 -109
  46. package/src/coverage.ts +830 -0
  47. package/src/dependencies.ts +14 -53
  48. package/src/dfid.ts +618 -0
  49. package/src/environment-config.ts +315 -0
  50. package/src/environment.ts +169 -335
  51. package/src/errors.ts +71 -55
  52. package/src/evaluate.ts +598 -340
  53. package/src/exit-codes.ts +37 -3
  54. package/src/fingerprints.ts +75 -11
  55. package/src/index.ts +3 -0
  56. package/src/instances.ts +126 -21
  57. package/src/java-hash.ts +7 -0
  58. package/src/java-overrides.ts +4 -19
  59. package/src/json-reader.ts +455 -0
  60. package/src/json.ts +252 -139
  61. package/src/levels.ts +46 -58
  62. package/src/lexer.ts +80 -100
  63. package/src/liveness-checker.ts +103 -153
  64. package/src/liveness.ts +150 -109
  65. package/src/obligations/action.ts +8 -39
  66. package/src/obligations/anonymize.ts +88 -82
  67. package/src/obligations/equality.ts +1 -1
  68. package/src/obligations/expression.ts +20 -21
  69. package/src/obligations/format.ts +1 -9
  70. package/src/obligations/generate.ts +46 -49
  71. package/src/obligations/index.ts +2 -13
  72. package/src/obligations/levels.ts +4 -8
  73. package/src/obligations/module.ts +28 -53
  74. package/src/obligations/normalize.ts +7 -25
  75. package/src/obligations/operators.ts +1 -2
  76. package/src/obligations/pragma.ts +1 -10
  77. package/src/obligations/printer.ts +47 -46
  78. package/src/obligations/proof.ts +1 -5
  79. package/src/obligations/regroup.ts +1 -4
  80. package/src/obligations/simplify.ts +42 -58
  81. package/src/obligations/source.ts +48 -78
  82. package/src/obligations/subexpression.ts +5 -11
  83. package/src/obligations/substitution.ts +1 -3
  84. package/src/obligations/temporal.ts +13 -19
  85. package/src/obligations/tuples.ts +3 -9
  86. package/src/parallel-worker.ts +30 -60
  87. package/src/parallel.ts +57 -71
  88. package/src/parser.ts +584 -316
  89. package/src/pcal/ast.ts +53 -86
  90. package/src/pcal/parse.ts +144 -219
  91. package/src/pcal/tokenize.ts +91 -131
  92. package/src/pcal/translate.ts +83 -130
  93. package/src/pcal/validate.ts +48 -68
  94. package/src/pretty-print.ts +7 -8
  95. package/src/prover/decide-pool.ts +8 -13
  96. package/src/prover/deciders.ts +3 -7
  97. package/src/prover/first-order.ts +0 -11
  98. package/src/prover/isabelle/decide.ts +0 -6
  99. package/src/prover/isabelle/encode.ts +11 -23
  100. package/src/prover/isabelle/isar/inner-syntax.ts +114 -115
  101. package/src/prover/isabelle/isar/method.ts +29 -53
  102. package/src/prover/isabelle/isar/proof.ts +1 -10
  103. package/src/prover/isabelle/isar/statement.ts +1 -6
  104. package/src/prover/isabelle/isar/theory.ts +26 -36
  105. package/src/prover/isabelle/isar/type-check.ts +17 -31
  106. package/src/prover/isabelle/provers/blast/blast.ts +17 -104
  107. package/src/prover/isabelle/provers/blast/branch.ts +1 -32
  108. package/src/prover/isabelle/provers/blast/prove.ts +1 -35
  109. package/src/prover/isabelle/provers/blast/rules.ts +6 -44
  110. package/src/prover/isabelle/provers/blast/state.ts +2 -28
  111. package/src/prover/isabelle/provers/blast/term.ts +9 -36
  112. package/src/prover/isabelle/provers/clasimp.ts +1 -13
  113. package/src/prover/isabelle/provers/classical.ts +14 -42
  114. package/src/prover/isabelle/provers/hypsubst.ts +28 -51
  115. package/src/prover/isabelle/pure/bicompose.ts +25 -38
  116. package/src/prover/isabelle/pure/consts.ts +1 -7
  117. package/src/prover/isabelle/pure/conv.ts +3 -17
  118. package/src/prover/isabelle/pure/drule.ts +33 -42
  119. package/src/prover/isabelle/pure/envir.ts +3 -52
  120. package/src/prover/isabelle/pure/goal.ts +1 -7
  121. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  122. package/src/prover/isabelle/pure/list.ts +0 -3
  123. package/src/prover/isabelle/pure/logic.ts +2 -15
  124. package/src/prover/isabelle/pure/name.ts +2 -9
  125. package/src/prover/isabelle/pure/net.ts +3 -59
  126. package/src/prover/isabelle/pure/object-logic.ts +3 -10
  127. package/src/prover/isabelle/pure/pattern.ts +2 -19
  128. package/src/prover/isabelle/pure/raw-simplifier.ts +17 -62
  129. package/src/prover/isabelle/pure/rewriter.ts +31 -67
  130. package/src/prover/isabelle/pure/search.ts +3 -10
  131. package/src/prover/isabelle/pure/seq.ts +1 -10
  132. package/src/prover/isabelle/pure/simplifier.ts +4 -12
  133. package/src/prover/isabelle/pure/table.ts +3 -32
  134. package/src/prover/isabelle/pure/tactic.ts +12 -22
  135. package/src/prover/isabelle/pure/tactical.ts +48 -47
  136. package/src/prover/isabelle/pure/term-ord.ts +2 -6
  137. package/src/prover/isabelle/pure/term.ts +2 -43
  138. package/src/prover/isabelle/pure/thm.ts +27 -47
  139. package/src/prover/isabelle/pure/type.ts +2 -15
  140. package/src/prover/isabelle/pure/unify.ts +20 -30
  141. package/src/prover/isabelle/pure/variable.ts +3 -7
  142. package/src/prover/isabelle/tla/classical-setup.ts +17 -24
  143. package/src/prover/isabelle/tla/context.ts +15 -18
  144. package/src/prover/isabelle/tla/logic.ts +14 -32
  145. package/src/prover/isabelle/tla/simpdata.ts +46 -43
  146. package/src/prover/isabelle/tools/intuitionistic.ts +1 -10
  147. package/src/prover/ocaml.ts +0 -6
  148. package/src/prover/prep/action.ts +14 -54
  149. package/src/prover/prep/enabled-axioms.ts +12 -19
  150. package/src/prover/prep/fingerprint.ts +2 -21
  151. package/src/prover/prep/level-comparison.ts +8 -12
  152. package/src/prover/prep/md5.ts +0 -2
  153. package/src/prover/prep/methods.ts +33 -39
  154. package/src/prover/prep/normalize.ts +4 -28
  155. package/src/prover/prove-worker.ts +0 -2
  156. package/src/prover/prove.ts +87 -100
  157. package/src/prover/ptl/decide.ts +7 -12
  158. package/src/prover/ptl/encode.ts +14 -36
  159. package/src/prover/ptl/sat.ts +24 -32
  160. package/src/prover/ptl/tableau.ts +12 -26
  161. package/src/prover/smt/axioms.ts +0 -7
  162. package/src/prover/smt/context.ts +20 -28
  163. package/src/prover/smt/data.ts +433 -424
  164. package/src/prover/smt/encode.ts +43 -52
  165. package/src/prover/smt/extensionality.ts +0 -10
  166. package/src/prover/smt/flatten.ts +3 -22
  167. package/src/prover/smt/format.ts +5 -10
  168. package/src/prover/smt/instances.ts +0 -10
  169. package/src/prover/smt/rewrite.ts +663 -667
  170. package/src/prover/smt/solver/act-cache.ts +0 -15
  171. package/src/prover/smt/solver/arith-rewriter.ts +3 -48
  172. package/src/prover/smt/solver/array.ts +1 -3
  173. package/src/prover/smt/solver/asserted-formulas.ts +1 -43
  174. package/src/prover/smt/solver/ast-lt.ts +1 -11
  175. package/src/prover/smt/solver/ast-util.ts +1 -6
  176. package/src/prover/smt/solver/ast.ts +1 -165
  177. package/src/prover/smt/solver/auf-solver.ts +8 -44
  178. package/src/prover/smt/solver/case-split-queue.ts +1 -9
  179. package/src/prover/smt/solver/cg-table.ts +1 -18
  180. package/src/prover/smt/solver/clause.ts +1 -27
  181. package/src/prover/smt/solver/conflict-resolution.ts +0 -9
  182. package/src/prover/smt/solver/context.ts +7 -64
  183. package/src/prover/smt/solver/ctx-simplify.ts +14 -41
  184. package/src/prover/smt/solver/der.ts +2 -21
  185. package/src/prover/smt/solver/dyn-ack.ts +1 -11
  186. package/src/prover/smt/solver/e-matching.ts +4 -35
  187. package/src/prover/smt/solver/enode.ts +1 -21
  188. package/src/prover/smt/solver/expr-ref.ts +1 -5
  189. package/src/prover/smt/solver/expr-safe-replace.ts +1 -6
  190. package/src/prover/smt/solver/fingerprints.ts +1 -12
  191. package/src/prover/smt/solver/flat-literals.ts +1 -9
  192. package/src/prover/smt/solver/goal.ts +2 -14
  193. package/src/prover/smt/solver/hash.ts +0 -8
  194. package/src/prover/smt/solver/hashtable.ts +1 -12
  195. package/src/prover/smt/solver/internalizer.ts +7 -100
  196. package/src/prover/smt/solver/lbool.ts +1 -2
  197. package/src/prover/smt/solver/literal.ts +0 -3
  198. package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
  199. package/src/prover/smt/solver/lp/constraints.ts +2 -8
  200. package/src/prover/smt/solver/lp/containers.ts +12 -30
  201. package/src/prover/smt/solver/lp/core-solver.ts +10 -31
  202. package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
  203. package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
  204. package/src/prover/smt/solver/lp/dependency.ts +1 -4
  205. package/src/prover/smt/solver/lp/dioph-eq.ts +9 -102
  206. package/src/prover/smt/solver/lp/explanation.ts +1 -6
  207. package/src/prover/smt/solver/lp/gomory.ts +9 -22
  208. package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
  209. package/src/prover/smt/solver/lp/hnf.ts +11 -26
  210. package/src/prover/smt/solver/lp/int-cube.ts +15 -36
  211. package/src/prover/smt/solver/lp/int-solver.ts +4 -34
  212. package/src/prover/smt/solver/lp/lar-solver.ts +32 -81
  213. package/src/prover/smt/solver/lp/lar-term.ts +1 -5
  214. package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
  215. package/src/prover/smt/solver/lp/maximize-term.ts +20 -45
  216. package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
  217. package/src/prover/smt/solver/lp/nex.ts +1 -6
  218. package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
  219. package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
  220. package/src/prover/smt/solver/lp/nla-core.ts +36 -135
  221. package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
  222. package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
  223. package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
  224. package/src/prover/smt/solver/lp/nla-grobner.ts +15 -69
  225. package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
  226. package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
  227. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
  228. package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
  229. package/src/prover/smt/solver/lp/nla-order.ts +2 -13
  230. package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
  231. package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
  232. package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
  233. package/src/prover/smt/solver/lp/nla-types.ts +1 -11
  234. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
  235. package/src/prover/smt/solver/lp/nra-solver.ts +5 -52
  236. package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
  237. package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
  238. package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
  239. package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
  240. package/src/prover/smt/solver/lp/pdd.ts +7 -70
  241. package/src/prover/smt/solver/lp/random-updater.ts +1 -8
  242. package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
  243. package/src/prover/smt/solver/lp/union-find.ts +1 -6
  244. package/src/prover/smt/solver/mam-compiler.ts +18 -58
  245. package/src/prover/smt/solver/mam-interpreter.ts +1 -21
  246. package/src/prover/smt/solver/maximize-ac-sharing.ts +2 -17
  247. package/src/prover/smt/solver/model-checker.ts +3 -37
  248. package/src/prover/smt/solver/model-evaluator.ts +3 -29
  249. package/src/prover/smt/solver/model-finder.ts +15 -32
  250. package/src/prover/smt/solver/model-generator.ts +1 -12
  251. package/src/prover/smt/solver/model-macro-solver.ts +23 -88
  252. package/src/prover/smt/solver/nlsat/algebraic.ts +63 -159
  253. package/src/prover/smt/solver/nlsat/atoms.ts +25 -23
  254. package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
  255. package/src/prover/smt/solver/nlsat/explain.ts +10 -69
  256. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -50
  257. package/src/prover/smt/solver/nlsat/levelwise.ts +49 -135
  258. package/src/prover/smt/solver/nlsat/mpbq.ts +3 -14
  259. package/src/prover/smt/solver/nlsat/polynomial.ts +29 -159
  260. package/src/prover/smt/solver/nlsat/solver.ts +18 -90
  261. package/src/prover/smt/solver/nlsat/types.ts +1 -8
  262. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +2 -45
  263. package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
  264. package/src/prover/smt/solver/nnf.ts +3 -38
  265. package/src/prover/smt/solver/pattern-inference.ts +2 -15
  266. package/src/prover/smt/solver/poly-rewriter.ts +3 -23
  267. package/src/prover/smt/solver/propagate-values.ts +1 -10
  268. package/src/prover/smt/solver/proto-model.ts +3 -52
  269. package/src/prover/smt/solver/pull-quant.ts +1 -12
  270. package/src/prover/smt/solver/qe-lite-der.ts +1 -29
  271. package/src/prover/smt/solver/qe-lite-fm.ts +2 -25
  272. package/src/prover/smt/solver/qe-lite.ts +3 -33
  273. package/src/prover/smt/solver/qi-queue.ts +1 -16
  274. package/src/prover/smt/solver/quant-tactics.ts +5 -22
  275. package/src/prover/smt/solver/quantifier-analyzer.ts +27 -47
  276. package/src/prover/smt/solver/quantifier-manager.ts +2 -13
  277. package/src/prover/smt/solver/random-gen.ts +1 -2
  278. package/src/prover/smt/solver/rational.ts +1 -8
  279. package/src/prover/smt/solver/ref-vector.ts +1 -6
  280. package/src/prover/smt/solver/relevancy.ts +2 -15
  281. package/src/prover/smt/solver/rewriter-tpl.ts +3 -147
  282. package/src/prover/smt/solver/rewriter.ts +3 -85
  283. package/src/prover/smt/solver/rlimit.ts +2 -20
  284. package/src/prover/smt/solver/smtlib-parser.ts +80 -131
  285. package/src/prover/smt/solver/solver.ts +23 -34
  286. package/src/prover/smt/solver/sort.ts +1 -5
  287. package/src/prover/smt/solver/sticky-generations.ts +0 -5
  288. package/src/prover/smt/solver/theory-lra-axioms.ts +3 -24
  289. package/src/prover/smt/solver/theory-lra-bounds.ts +1 -7
  290. package/src/prover/smt/solver/theory-lra-final-check.ts +4 -22
  291. package/src/prover/smt/solver/theory-lra-internalize.ts +6 -43
  292. package/src/prover/smt/solver/theory-lra-model.ts +4 -19
  293. package/src/prover/smt/solver/theory-lra-propagate.ts +1 -15
  294. package/src/prover/smt/solver/theory-lra-state.ts +3 -8
  295. package/src/prover/smt/solver/theory-lra.ts +1 -8
  296. package/src/prover/smt/solver/var-subst.ts +2 -26
  297. package/src/prover/smt/table.ts +0 -8
  298. package/src/prover/tlapm/cache.ts +45 -40
  299. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  300. package/src/prover/tlapm/tlapm.ts +21 -20
  301. package/src/prover/verdict.ts +7 -2
  302. package/src/prover/zenon/check/check.ts +1 -11
  303. package/src/prover/zenon/check/definitions.ts +5 -15
  304. package/src/prover/zenon/check/equality.ts +0 -8
  305. package/src/prover/zenon/check/functions.ts +0 -4
  306. package/src/prover/zenon/check/keys.ts +0 -7
  307. package/src/prover/zenon/check/propositional.ts +0 -3
  308. package/src/prover/zenon/check/records.ts +1 -6
  309. package/src/prover/zenon/check/relations.ts +2 -14
  310. package/src/prover/zenon/check/rewrites.ts +2 -21
  311. package/src/prover/zenon/check/sets.ts +40 -61
  312. package/src/prover/zenon/check/terms.ts +1 -19
  313. package/src/prover/zenon/check/tla.ts +0 -6
  314. package/src/prover/zenon/decide.ts +0 -12
  315. package/src/prover/zenon/encode.ts +1 -8
  316. package/src/prover/zenon/eqrel.ts +2 -13
  317. package/src/prover/zenon/equality-rules.ts +0 -4
  318. package/src/prover/zenon/expr.ts +8 -26
  319. package/src/prover/zenon/index-table.ts +26 -57
  320. package/src/prover/zenon/isar-case.ts +9 -19
  321. package/src/prover/zenon/isar.ts +36 -64
  322. package/src/prover/zenon/limits.ts +0 -4
  323. package/src/prover/zenon/llproof.ts +2 -20
  324. package/src/prover/zenon/mltoll.ts +66 -104
  325. package/src/prover/zenon/node.ts +1 -11
  326. package/src/prover/zenon/ocaml.ts +1 -17
  327. package/src/prover/zenon/parse.ts +4 -12
  328. package/src/prover/zenon/phrase.ts +1 -11
  329. package/src/prover/zenon/proof.ts +0 -9
  330. package/src/prover/zenon/propositional-rules.ts +0 -5
  331. package/src/prover/zenon/rules.ts +2 -6
  332. package/src/prover/zenon/search.ts +5 -31
  333. package/src/prover/zenon/tla/functions.ts +59 -31
  334. package/src/prover/zenon/tla/llproof.ts +67 -76
  335. package/src/prover/zenon/tla/records.ts +57 -33
  336. package/src/prover/zenon/tla/rewrites.ts +12 -19
  337. package/src/prover/zenon/tla/sets.ts +83 -53
  338. package/src/prover/zenon/tla/terms.ts +0 -6
  339. package/src/prover/zenon/tla/tla.ts +66 -64
  340. package/src/randomization.ts +81 -35
  341. package/src/resolve.ts +67 -184
  342. package/src/runtime.ts +22 -22
  343. package/src/sany/builtins.ts +2 -5
  344. package/src/sany/generation.ts +394 -0
  345. package/src/sany/generator-def-entries.ts +210 -0
  346. package/src/sany/generator-definitions.ts +686 -0
  347. package/src/sany/generator-expressions.ts +1100 -0
  348. package/src/sany/generator-proofs.ts +662 -0
  349. package/src/sany/generator.ts +191 -2764
  350. package/src/sany/levels.ts +6 -34
  351. package/src/sany/lexer.ts +58 -77
  352. package/src/sany/linter.ts +1 -9
  353. package/src/sany/modules.ts +1 -5
  354. package/src/sany/nodes.ts +5 -43
  355. package/src/sany/parse-error.ts +39 -117
  356. package/src/sany/report.ts +32 -69
  357. package/src/sany/selectors.ts +49 -76
  358. package/src/sany/source.ts +1 -17
  359. package/src/sany/xml.ts +35 -117
  360. package/src/search.ts +541 -163
  361. package/src/simulate.ts +709 -0
  362. package/src/spec-description.ts +192 -100
  363. package/src/standard-definitions.ts +0 -4
  364. package/src/standard-modules.ts +264 -95
  365. package/src/state-graph.ts +52 -31
  366. package/src/subexpressions.ts +69 -52
  367. package/src/substitution-levels.ts +7 -7
  368. package/src/successors.ts +266 -99
  369. package/src/symmetry.ts +33 -25
  370. package/src/tableau.ts +27 -24
  371. package/src/tlc/fingerprint.ts +183 -67
  372. package/src/tlc/jar-data.ts +112 -6
  373. package/src/tlc/messages.ts +125 -54
  374. package/src/tlc/order.ts +39 -69
  375. package/src/tlc/random.ts +37 -49
  376. package/src/tlc/replay.ts +553 -228
  377. package/src/tlc/summary.ts +36 -47
  378. package/src/tlc/tlc-operators.ts +78 -44
  379. package/src/tlc/tlcext-operators.ts +139 -122
  380. package/src/tlc/trace-spec.ts +249 -0
  381. package/src/tlc/value-stream.ts +139 -0
  382. package/src/tlc/version.ts +1 -4
  383. package/src/transfer.ts +22 -25
  384. package/src/typescript/actions.ts +479 -0
  385. package/src/typescript/collections.ts +614 -0
  386. package/src/typescript/compile.ts +63 -0
  387. package/src/typescript/context.ts +94 -0
  388. package/src/typescript/emit.ts +121 -0
  389. package/src/typescript/expressions.ts +496 -0
  390. package/src/typescript/formula.ts +154 -0
  391. package/src/typescript/functions.ts +284 -0
  392. package/src/typescript/model.ts +162 -0
  393. package/src/typescript/names.ts +114 -0
  394. package/src/typescript/program.ts +48 -0
  395. package/src/typescript/properties.ts +139 -0
  396. package/src/typescript/scope.ts +112 -0
  397. package/src/typescript/steps.ts +167 -0
  398. package/src/typescript/types.ts +171 -0
  399. package/src/values.ts +832 -484
  400. package/src/worker.ts +7 -8
@@ -1,10 +1,6 @@
1
- // encode/n_rewrite.ml, type/t_synth.ml, and encode/n_standardize.ml: a TLA+ expression as an
2
- // SMT-LIB term over the sort Idv. Set extensionality is in extensionality.ts, and the axioms each
3
- // flattened symbol brings are in instances.ts.
4
-
5
1
  import { TlaUnsupportedError } from "../../errors";
6
2
  import { normalizeApply, shiftExpr } from "../../obligations/substitution";
7
- import { type Bound, type Builtin, type Expr, type Sequent } from "../../obligations/expression";
3
+ import type { Bound, Builtin, Expr, Sequent } from "../../obligations/expression";
8
4
  import { createContext, type Identifier } from "./context";
9
5
  import {
10
6
  createFlattener,
@@ -48,17 +44,14 @@ import {
48
44
  interface Term {
49
45
  isBool: boolean;
50
46
  text: string;
51
- // Type.Synthesize: the Int-sorted form of a term that is an integer before it's cast to Idv.
52
47
  integer?: string;
53
48
  }
54
49
 
55
- // What tlapm keeps across the obligations of one run.
56
50
  export interface EncodingSession {
57
51
  caseErrors: number;
58
52
  }
59
53
 
60
54
  export interface Mode {
61
- // Whether the text encodes a fact that tlapm leaves out, which may declare operators.
62
55
  isOmitted: boolean;
63
56
  polarity: Polarity;
64
57
  at: string | undefined;
@@ -77,690 +70,693 @@ export interface Env {
77
70
  rest: Env | undefined;
78
71
  }
79
72
 
80
- // A nested ASSUME's declarations and facts so far: each wraps the goal in a quantifier or an
81
- // implication.
73
+ export interface Encoder {
74
+ session: EncodingSession;
75
+ flattener: ReturnType<typeof createFlattener>;
76
+ anonymous: Map<string, number>;
77
+ recordFields: Map<string, string[]>;
78
+ context: ReturnType<typeof createContext>;
79
+ declared: Map<string, Identifier>;
80
+ }
81
+
82
82
  interface NestedContext {
83
83
  env: Env | undefined;
84
84
  mode: Mode;
85
85
  wrappers: ((body: string) => string)[];
86
86
  }
87
87
 
88
- export const createEncoder = (session: EncodingSession) => {
89
- const flattener = createFlattener();
90
- const flatten = flattener.flatten;
91
- // The arity of each anonymous operator Coalesce introduces.
92
- const anonymous = new Map<string, number>();
93
- // The fields of each record symbol.
94
- const recordFields = new Map<string, string[]>();
95
- const context = createContext();
96
- // The salted name of each declared user symbol, for the printer's context.
97
- const declared = new Map<string, Identifier>();
98
-
99
- // Standardize wraps a cast term in an application, and set_extensionality_visitor visits the
100
- // arguments of an application with neither polarity, so a cast triggers every set equality in it.
101
- const toBool = (term: Term) =>
102
- term.isBool ? term.text : `(= ${resolveTriggers(term.text, true)} ${TT_IDV})`;
103
-
104
- const toIdv = (term: Term) =>
105
- term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
106
-
107
- const bool = (text: string): Term => ({ isBool: true, text });
108
-
109
- const idv = (text: string): Term => ({ isBool: false, text });
110
-
111
- const getBinding = (env: Env | undefined, index: number): Binding => {
112
- const found = Array.from({ length: index - 1 }).reduce<Env | undefined>(
113
- (current) => current?.rest,
114
- env,
115
- );
116
- if (!found) throw new TlaUnsupportedError("a reference outside the obligation");
117
- return found.binding;
118
- };
119
-
120
- const push = (env: Env | undefined, binding: Binding): Env => ({ binding, rest: env });
121
-
122
- // The variables bound outside depth that text uses, outermost first.
123
- const getFree = (text: string, depth: number) =>
124
- [...new Set(text.match(/[^\s()]+#\d+/g))]
125
- .filter((variable) => getDepth(variable) < depth)
126
- .toSorted((left, right) => getDepth(left) - getDepth(right));
127
-
128
- // Smtlib.adj: the Action frontend's name, salted while it's taken.
129
- const getUniqueName = (name: string) => {
130
- const identifier = context.adjoin(name);
131
- context.enter(identifier);
132
- declared.set(identifier.name, identifier);
133
- return identifier.name;
134
- };
135
-
136
- const neither = (mode: Mode): Mode => ({ ...mode, polarity: "Neither" });
137
-
138
- const invert = (mode: Mode): Mode => ({
139
- ...mode,
140
- polarity:
141
- mode.polarity === "Positive"
142
- ? "Negative"
143
- : mode.polarity === "Negative"
144
- ? "Positive"
145
- : "Neither",
88
+ const toBool = (term: Term) =>
89
+ term.isBool ? term.text : `(= ${resolveTriggers(term.text, true)} ${TT_IDV})`;
90
+
91
+ const toIdv = (term: Term) =>
92
+ term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
93
+
94
+ const wrapBool = (text: string): Term => ({ isBool: true, text });
95
+
96
+ const wrapIdv = (text: string): Term => ({ isBool: false, text });
97
+
98
+ const getBinding = (env: Env | undefined, index: number): Binding => {
99
+ const found = Array.from({ length: index - 1 }).reduce<Env | undefined>(
100
+ (current) => current?.rest,
101
+ env,
102
+ );
103
+ if (!found) throw new TlaUnsupportedError("a reference outside the obligation");
104
+ return found.binding;
105
+ };
106
+
107
+ export const push = (env: Env | undefined, binding: Binding): Env => ({ binding, rest: env });
108
+
109
+ const getFree = (text: string, depth: number) =>
110
+ [...new Set(text.match(/[^\s()]+#\d+/g))]
111
+ .filter((variable) => getDepth(variable) < depth)
112
+ .toSorted((left, right) => getDepth(left) - getDepth(right));
113
+
114
+ export const getUniqueName = (encoder: Encoder, name: string) => {
115
+ const identifier = encoder.context.adjoin(name);
116
+ encoder.context.enter(identifier);
117
+ encoder.declared.set(identifier.name, identifier);
118
+ return identifier.name;
119
+ };
120
+
121
+ const clearPolarity = (mode: Mode): Mode => ({ ...mode, polarity: "Neither" });
122
+
123
+ const invert = (mode: Mode): Mode => ({
124
+ ...mode,
125
+ polarity:
126
+ mode.polarity === "Positive"
127
+ ? "Negative"
128
+ : mode.polarity === "Negative"
129
+ ? "Positive"
130
+ : "Neither",
131
+ });
132
+
133
+ export const encodeIdv = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
134
+ toIdv(encode(encoder, expression, env, clearPolarity(mode)));
135
+
136
+ export const encodeBool = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
137
+ toBool(encode(encoder, expression, env, mode));
138
+
139
+ // tlapm's Rewrite encodes each Ditto's copy of a domain, so each copy flattens again.
140
+ const encodeDomains = (encoder: Encoder, bounds: Bound[], env: Env | undefined, mode: Mode) =>
141
+ bounds
142
+ .reduce<(Expr | undefined)[]>((domains, bound) => {
143
+ if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
144
+ if (bound.domain.kind === "NoDomain") return [...domains, undefined];
145
+ return [...domains, bound.domain.expression];
146
+ }, [])
147
+ .map((domain) => (domain === undefined ? undefined : encodeIdv(encoder, domain, env, mode)));
148
+
149
+ const getDomains = (
150
+ encoder: Encoder,
151
+ bounds: Bound[],
152
+ env: Env | undefined,
153
+ mode: Mode,
154
+ construct: string,
155
+ ) =>
156
+ encodeDomains(encoder, bounds, env, mode).map((domain) => {
157
+ if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
158
+ return domain;
146
159
  });
147
160
 
148
- const encodeIdv = (expression: Expr, env: Env | undefined, mode: Mode) =>
149
- toIdv(encode(expression, env, neither(mode)));
150
-
151
- const encodeBool = (expression: Expr, env: Env | undefined, mode: Mode) =>
152
- toBool(encode(expression, env, mode));
153
-
154
- // The domains of bounds, each in the scope outside them. A Ditto copies the last domain, and
155
- // tlapm's Rewrite encodes each copy, so each one flattens again.
156
- const encodeDomains = (bounds: Bound[], env: Env | undefined, mode: Mode) =>
157
- bounds
158
- .reduce<(Expr | undefined)[]>((domains, bound) => {
159
- if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
160
- if (bound.domain.kind === "NoDomain") return [...domains, undefined];
161
- return [...domains, bound.domain.expression];
162
- }, [])
163
- .map((domain) => (domain === undefined ? undefined : encodeIdv(domain, env, mode)));
164
-
165
- const getDomains = (bounds: Bound[], env: Env | undefined, mode: Mode, construct: string) =>
166
- encodeDomains(bounds, env, mode).map((domain) => {
167
- if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
168
- return domain;
169
- });
170
-
171
- const bindVariables = (names: string[], env: Env | undefined, mode: Mode) => {
172
- const variables = names.map((name, index) => getVariable(name, mode.depth + index));
173
- const inner = variables.reduce<Env | undefined>(
174
- (current, symbol) => push(current, { kind: "constant", symbol }),
175
- env,
176
- );
177
- return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
178
- };
179
-
180
- const encodeQuantifier = (
181
- expression: Extract<Expr, { kind: "Quant" }>,
182
- env: Env | undefined,
183
- mode: Mode,
184
- ) => {
185
- const domains = encodeDomains(expression.bounds, env, mode);
186
- const bound = bindVariables(
187
- expression.bounds.map((innerBound) => innerBound.name),
188
- env,
189
- mode,
190
- );
191
- const body = encodeBool(expression.body, bound.env, bound.mode);
192
- const guards = bound.variables.flatMap((variable, index) =>
193
- domains[index] === undefined ? [] : [`(${MEM} ${variable} ${domains[index]})`],
194
- );
195
- return expression.quantifier === "Forall"
196
- ? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
197
- : `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
198
- };
199
-
200
- const encodeSetSt = (
201
- expression: Extract<Expr, { kind: "SetSt" }>,
202
- env: Env | undefined,
203
- mode: Mode,
204
- ) => {
205
- const domain = encodeIdv(expression.domain, env, mode);
206
- const bound = bindVariables([expression.name], env, neither(mode));
207
- const body = encodeBool(expression.body, bound.env, bound.mode);
208
- const free = getFree(body, mode.depth);
209
- const symbol = flatten(
210
- "SetSt",
211
- body,
212
- mode,
213
- (name) => getSetStAxioms(name, free, body, bound.variables[0]),
214
- free.length + 1,
215
- );
216
- return idv(call(symbol, [domain, ...free]));
217
- };
218
-
219
- const encodeSetOf = (
220
- expression: Extract<Expr, { kind: "SetOf" }>,
221
- env: Env | undefined,
222
- mode: Mode,
223
- ) => {
224
- const domains = getDomains(expression.bounds, env, mode, "a set of values");
225
- const bound = bindVariables(
226
- expression.bounds.map((innerBound) => innerBound.name),
227
- env,
228
- neither(mode),
229
- );
230
- const element = encodeIdv(expression.element, bound.env, bound.mode);
231
- const free = getFree(element, mode.depth);
232
- const count = domains.length;
233
- const symbol = flatten(
234
- `SetOf_${count}`,
235
- element,
236
- mode,
237
- (name) => getSetOfAxioms(name, free, element, bound.variables),
238
- count + free.length,
239
- );
240
- return idv(call(symbol, [...domains, ...free]));
241
- };
242
-
243
- // Rewrite.elim_multiarg: a function of several arguments is a function of a tuple.
244
- const encodeFunction = (
245
- expression: Extract<Expr, { kind: "Fcn" }>,
246
- env: Env | undefined,
247
- mode: Mode,
248
- ) => {
249
- const domains = getDomains(expression.bounds, env, mode, "a function");
250
- const domain =
251
- domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
252
- const variable = getVariable(
253
- domains.length === 1 ? expression.bounds[0].name : "x",
254
- mode.depth,
255
- );
256
- const inner = { ...neither(mode), depth: mode.depth + 1 };
257
- const bodyEnv =
258
- domains.length === 1
259
- ? push(env, { kind: "constant", symbol: variable })
260
- : getIntegers(domains.length).reduce<Env | undefined>(
261
- (current, key) =>
262
- push(current, { kind: "constant", symbol: `(${FUN_APP} ${variable} ${key})` }),
263
- env,
264
- );
265
- const body = encodeIdv(expression.body, bodyEnv, inner);
266
- const free = getFree(body, mode.depth);
267
- const symbol = flatten(
268
- "FunFcn",
269
- body,
270
- mode,
271
- (name, axioms) => getFunctionAxioms(name, free, body, variable, axioms),
272
- free.length + 1,
273
- );
274
- return idv(call(symbol, [domain, ...free]));
275
- };
276
-
277
- // Elab: CHOOSE x \in S : P is CHOOSE x : x \in S /\ P.
278
- const encodeChoose = (
279
- expression: Extract<Expr, { kind: "Choose" }>,
280
- env: Env | undefined,
281
- mode: Mode,
282
- ) => {
283
- const bound = bindVariables([expression.name], env, neither(mode));
284
- const variable = bound.variables[0];
285
- const domain =
286
- expression.domain && `(${MEM} ${variable} ${encodeIdv(expression.domain, env, mode)})`;
287
- const predicate = encodeBool(expression.body, bound.env, bound.mode);
288
- const body = domain === undefined ? predicate : conjoin([domain, predicate]);
289
- const free = getFree(body, mode.depth);
290
- const symbol = flatten(
291
- "Choose",
292
- body,
293
- mode,
294
- (name) => getChooseAxioms(name, free, body, variable),
295
- free.length,
296
- );
297
- return idv(call(symbol, free));
298
- };
299
-
300
- // Type.Synthesize compares values of the same sort only above type level 1, so two formulas are
301
- // compared as values.
302
- const encodeEquality = (args: Expr[], env: Env | undefined, mode: Mode, isNegated: boolean) =>
303
- getEquality(
304
- encodeIdv(args[0], env, mode),
305
- encodeIdv(args[1], env, mode),
306
- mode.polarity,
307
- isNegated,
308
- );
161
+ const bindVariables = (names: string[], env: Env | undefined, mode: Mode) => {
162
+ const variables = names.map((name, index) => getVariable(name, mode.depth + index));
163
+ const inner = variables.reduce<Env | undefined>(
164
+ (current, symbol) => push(current, { kind: "constant", symbol }),
165
+ env,
166
+ );
167
+ return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
168
+ };
309
169
 
310
- // Type.Synthesize: SelectSeq's test becomes the predicate LAMBDA x1 : Test(x1), its body the
311
- // text Flatten compares.
312
- const getSelectionTest = (test: Expr, env: Env | undefined, mode: Mode) => {
313
- const lambda = test.kind === "Lambda" && test.params.length === 1 ? test : undefined;
314
- const bound = bindVariables([lambda?.params[0].name ?? "x1"], env, neither(mode));
315
- const body = encodeBool(
316
- lambda?.body ?? {
317
- kind: "Apply",
318
- operator: shiftExpr(1, test),
319
- args: [{ kind: "Ix", index: 1 }],
320
- },
321
- bound.env,
322
- bound.mode,
323
- );
324
- return { body, variable: bound.variables[0] };
325
- };
326
-
327
- const encodeBuiltin = (
328
- builtin: Builtin,
329
- args: Expr[],
330
- env: Env | undefined,
331
- mode: Mode,
332
- ): Term => {
333
- const idvs = () => args.map((arg) => encodeIdv(arg, env, mode));
334
- switch (builtin) {
335
- case "Conj":
336
- return bool(conjoin(args.map((arg) => encodeBool(arg, env, mode))));
337
- case "Disj":
338
- return bool(disjoin(args.map((arg) => encodeBool(arg, env, mode))));
339
- case "Implies":
340
- return bool(
341
- `(=> ${encodeBool(args[0], env, invert(mode))} ${encodeBool(args[1], env, mode)})`,
342
- );
343
- case "Equiv":
344
- return bool(`(= ${args.map((arg) => encodeBool(arg, env, neither(mode))).join(" ")})`);
345
- case "Neg":
346
- return bool(`(not ${encodeBool(args[0], env, invert(mode))})`);
347
- case "Eq":
348
- return bool(encodeEquality(args, env, mode, false));
349
- case "Neq":
350
- return bool(encodeEquality(args, env, mode, true));
351
- case "Mem":
352
- return bool(call(MEM, idvs()));
353
- // Rewrite.elim_notmem: a \notin S is ~(a \in S).
354
- case "Notmem":
355
- return bool(`(not ${call(MEM, idvs())})`);
356
- case "Subseteq":
357
- return bool(call(SUBSET_EQ, idvs()));
358
- // Rewrite.elim_compare: a < b is a <= b /\ a # b, and a > b is b < a.
359
- case "Lteq":
360
- return bool(call(INT_LTEQ, idvs()));
361
- case "Gteq":
362
- return bool(call(INT_LTEQ, idvs().toReversed()));
363
- case "Lt":
364
- case "Gt": {
365
- // Rewrite copies the operands before Flatten, which flattens each copy again.
366
- const getOperands = () => (builtin === "Lt" ? idvs() : idvs().toReversed());
367
- return bool(`(and ${call(INT_LTEQ, getOperands())} (distinct ${getOperands().join(" ")}))`);
368
- }
369
- // Flatten: SelectSeq(s, Test) is a fresh operator of s and the bound variables Test uses.
370
- case "SelectSeq": {
371
- const test = getSelectionTest(args[1], env, mode);
372
- const free = getFree(test.body, mode.depth);
373
- const symbol = flatten(
374
- "SelectSeq",
375
- test.body,
376
- mode,
377
- (name) => getSelectSeqAxioms(name, free, test.body, test.variable),
378
- free.length + 1,
170
+ const encodeQuantifier = (
171
+ encoder: Encoder,
172
+ expression: Extract<Expr, { kind: "Quant" }>,
173
+ env: Env | undefined,
174
+ mode: Mode,
175
+ ) => {
176
+ const domains = encodeDomains(encoder, expression.bounds, env, mode);
177
+ const bound = bindVariables(
178
+ expression.bounds.map((innerBound) => innerBound.name),
179
+ env,
180
+ mode,
181
+ );
182
+ const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
183
+ const guards = bound.variables.flatMap((variable, index) =>
184
+ domains[index] === undefined ? [] : [`(${MEM} ${variable} ${domains[index]})`],
185
+ );
186
+ return expression.quantifier === "Forall"
187
+ ? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
188
+ : `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
189
+ };
190
+
191
+ const encodeSetSt = (
192
+ encoder: Encoder,
193
+ expression: Extract<Expr, { kind: "SetSt" }>,
194
+ env: Env | undefined,
195
+ mode: Mode,
196
+ ) => {
197
+ const domain = encodeIdv(encoder, expression.domain, env, mode);
198
+ const bound = bindVariables([expression.name], env, clearPolarity(mode));
199
+ const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
200
+ const free = getFree(body, mode.depth);
201
+ const symbol = encoder.flattener.flatten(
202
+ "SetSt",
203
+ body,
204
+ mode,
205
+ (name) => getSetStAxioms(name, free, body, bound.variables[0]),
206
+ free.length + 1,
207
+ );
208
+ return wrapIdv(call(symbol, [domain, ...free]));
209
+ };
210
+
211
+ const encodeSetOf = (
212
+ encoder: Encoder,
213
+ expression: Extract<Expr, { kind: "SetOf" }>,
214
+ env: Env | undefined,
215
+ mode: Mode,
216
+ ) => {
217
+ const domains = getDomains(encoder, expression.bounds, env, mode, "a set of values");
218
+ const bound = bindVariables(
219
+ expression.bounds.map((innerBound) => innerBound.name),
220
+ env,
221
+ clearPolarity(mode),
222
+ );
223
+ const element = encodeIdv(encoder, expression.element, bound.env, bound.mode);
224
+ const free = getFree(element, mode.depth);
225
+ const count = domains.length;
226
+ const symbol = encoder.flattener.flatten(
227
+ `SetOf_${count}`,
228
+ element,
229
+ mode,
230
+ (name) => getSetOfAxioms(name, free, element, bound.variables),
231
+ count + free.length,
232
+ );
233
+ return wrapIdv(call(symbol, [...domains, ...free]));
234
+ };
235
+
236
+ const encodeFunction = (
237
+ encoder: Encoder,
238
+ expression: Extract<Expr, { kind: "Fcn" }>,
239
+ env: Env | undefined,
240
+ mode: Mode,
241
+ ) => {
242
+ const domains = getDomains(encoder, expression.bounds, env, mode, "a function");
243
+ const domain =
244
+ domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
245
+ const variable = getVariable(domains.length === 1 ? expression.bounds[0].name : "x", mode.depth);
246
+ const inner = { ...clearPolarity(mode), depth: mode.depth + 1 };
247
+ const bodyEnv =
248
+ domains.length === 1
249
+ ? push(env, { kind: "constant", symbol: variable })
250
+ : getIntegers(domains.length).reduce<Env | undefined>(
251
+ (current, key) =>
252
+ push(current, { kind: "constant", symbol: `(${FUN_APP} ${variable} ${key})` }),
253
+ env,
379
254
  );
380
- return idv(call(symbol, [encodeIdv(args[0], env, mode), ...free]));
381
- }
382
- case "Unprimable": {
383
- const term = encode(args[0], env, neither(mode));
384
- return { ...term, text: `(${UNPRIMABLE} ${term.text})` };
385
- }
386
- default: {
387
- const symbol = BUILTIN_SYMBOLS[builtin];
388
- if (symbol === undefined) throw new TlaUnsupportedError(`the operator ${builtin}`);
389
- return idv(call(symbol, idvs()));
390
- }
255
+ const body = encodeIdv(encoder, expression.body, bodyEnv, inner);
256
+ const free = getFree(body, mode.depth);
257
+ const symbol = encoder.flattener.flatten(
258
+ "FunFcn",
259
+ body,
260
+ mode,
261
+ (name, axioms) => getFunctionAxioms(name, free, body, variable, axioms),
262
+ free.length + 1,
263
+ );
264
+ return wrapIdv(call(symbol, [domain, ...free]));
265
+ };
266
+
267
+ const encodeChoose = (
268
+ encoder: Encoder,
269
+ expression: Extract<Expr, { kind: "Choose" }>,
270
+ env: Env | undefined,
271
+ mode: Mode,
272
+ ) => {
273
+ const bound = bindVariables([expression.name], env, clearPolarity(mode));
274
+ const variable = bound.variables[0];
275
+ const domain =
276
+ expression.domain && `(${MEM} ${variable} ${encodeIdv(encoder, expression.domain, env, mode)})`;
277
+ const predicate = encodeBool(encoder, expression.body, bound.env, bound.mode);
278
+ const body = domain === undefined ? predicate : conjoin([domain, predicate]);
279
+ const free = getFree(body, mode.depth);
280
+ const symbol = encoder.flattener.flatten(
281
+ "Choose",
282
+ body,
283
+ mode,
284
+ (name) => getChooseAxioms(name, free, body, variable),
285
+ free.length,
286
+ );
287
+ return wrapIdv(call(symbol, free));
288
+ };
289
+
290
+ const encodeEquality = (
291
+ encoder: Encoder,
292
+ args: Expr[],
293
+ env: Env | undefined,
294
+ mode: Mode,
295
+ isNegated: boolean,
296
+ ) =>
297
+ getEquality(
298
+ encodeIdv(encoder, args[0], env, mode),
299
+ encodeIdv(encoder, args[1], env, mode),
300
+ mode.polarity,
301
+ isNegated,
302
+ );
303
+
304
+ const getSelectionTest = (encoder: Encoder, test: Expr, env: Env | undefined, mode: Mode) => {
305
+ const lambda = test.kind === "Lambda" && test.params.length === 1 ? test : undefined;
306
+ const bound = bindVariables([lambda?.params[0].name ?? "x1"], env, clearPolarity(mode));
307
+ const body = encodeBool(
308
+ encoder,
309
+ lambda?.body ?? {
310
+ kind: "Apply",
311
+ operator: shiftExpr(1, test),
312
+ args: [{ kind: "Ix", index: 1 }],
313
+ },
314
+ bound.env,
315
+ bound.mode,
316
+ );
317
+ return { body, variable: bound.variables[0] };
318
+ };
319
+
320
+ const encodeBuiltin = (
321
+ encoder: Encoder,
322
+ builtin: Builtin,
323
+ args: Expr[],
324
+ env: Env | undefined,
325
+ mode: Mode,
326
+ ): Term => {
327
+ const encodeArgs = () => args.map((arg) => encodeIdv(encoder, arg, env, mode));
328
+ switch (builtin) {
329
+ case "Conj":
330
+ return wrapBool(conjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
331
+ case "Disj":
332
+ return wrapBool(disjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
333
+ case "Implies":
334
+ return wrapBool(
335
+ `(=> ${encodeBool(encoder, args[0], env, invert(mode))} ${encodeBool(encoder, args[1], env, mode)})`,
336
+ );
337
+ case "Equiv":
338
+ return wrapBool(
339
+ `(= ${args.map((arg) => encodeBool(encoder, arg, env, clearPolarity(mode))).join(" ")})`,
340
+ );
341
+ case "Neg":
342
+ return wrapBool(`(not ${encodeBool(encoder, args[0], env, invert(mode))})`);
343
+ case "Eq":
344
+ return wrapBool(encodeEquality(encoder, args, env, mode, false));
345
+ case "Neq":
346
+ return wrapBool(encodeEquality(encoder, args, env, mode, true));
347
+ case "Mem":
348
+ return wrapBool(call(MEM, encodeArgs()));
349
+ case "Notmem":
350
+ return wrapBool(`(not ${call(MEM, encodeArgs())})`);
351
+ case "Subseteq":
352
+ return wrapBool(call(SUBSET_EQ, encodeArgs()));
353
+ case "Lteq":
354
+ return wrapBool(call(INT_LTEQ, encodeArgs()));
355
+ case "Gteq":
356
+ return wrapBool(call(INT_LTEQ, encodeArgs().toReversed()));
357
+ case "Lt":
358
+ case "Gt": {
359
+ // Rewrite copies the operands before Flatten, which flattens each copy again.
360
+ const getOperands = () => (builtin === "Lt" ? encodeArgs() : encodeArgs().toReversed());
361
+ return wrapBool(
362
+ `(and ${call(INT_LTEQ, getOperands())} (distinct ${getOperands().join(" ")}))`,
363
+ );
391
364
  }
392
- };
393
-
394
- const encodeReference = (
395
- binding: Binding,
396
- args: Expr[],
397
- env: Env | undefined,
398
- mode: Mode,
399
- ): Term => {
400
- switch (binding.kind) {
401
- case "constant":
402
- case "variable":
403
- if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
404
- return idv(binding.symbol);
405
- case "operator":
406
- if (args.length !== binding.arity)
407
- throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
408
- return idv(
409
- call(
410
- binding.symbol,
411
- args.map((arg) => encodeIdv(arg, env, mode)),
412
- ),
413
- );
414
- // Flatten: an application of a second-order operator, which has no axioms, is a fresh
415
- // operator of its first-order arguments and the bound variables its others use.
416
- case "secondOrder": {
417
- if (args.length !== binding.shapes.length)
418
- throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
419
- const operands = args.map((arg, index) => {
420
- if (binding.shapes[index] === 0)
421
- return { isFirstOrder: true, text: encodeIdv(arg, env, mode) };
422
- // An operator's name as the argument stands for the operator, which compare_expr
423
- // matches by name.
424
- if (arg.kind === "Ix") {
425
- const argument = getBinding(env, arg.index);
426
- if (argument.kind !== "operator")
427
- throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
428
- return { isFirstOrder: false, text: argument.symbol };
429
- }
430
- if (arg.kind !== "Lambda")
431
- throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
432
- const bound = bindVariables(
433
- arg.params.map((param) => param.name),
434
- env,
435
- neither(mode),
436
- );
437
- return { isFirstOrder: false, text: encodeIdv(arg.body, bound.env, bound.mode) };
438
- });
439
- const firstOrder = operands.flatMap((operand) =>
440
- operand.isFirstOrder ? [operand.text] : [],
441
- );
442
- const higherOrder = operands.flatMap((operand) =>
443
- operand.isFirstOrder ? [] : [operand.text],
444
- );
445
- const free = getFree(higherOrder.join(" "), mode.depth);
446
- const symbol = flatten(
447
- "",
448
- higherOrder.join(" "),
449
- mode,
450
- () => [],
451
- firstOrder.length + free.length,
452
- binding.name,
453
- );
454
- return idv(call(symbol, [...firstOrder, ...free]));
455
- }
456
- case "unsupported":
457
- throw new TlaUnsupportedError(binding.reason);
365
+ case "SelectSeq": {
366
+ const test = getSelectionTest(encoder, args[1], env, mode);
367
+ const free = getFree(test.body, mode.depth);
368
+ const symbol = encoder.flattener.flatten(
369
+ "SelectSeq",
370
+ test.body,
371
+ mode,
372
+ (name) => getSelectSeqAxioms(name, free, test.body, test.variable),
373
+ free.length + 1,
374
+ );
375
+ return wrapIdv(call(symbol, [encodeIdv(encoder, args[0], env, mode), ...free]));
458
376
  }
459
- };
460
-
461
- // Rewrite.elim_flex: the Action frontend's name#prime is the primed copy of the variable it
462
- // names, which tlapm finds by name.
463
- const getPrimed = (env: Env | undefined, name: string): string => {
464
- if (!env) throw new TlaUnsupportedError(`a primed declaration that isn't a variable`);
465
- const binding = env.binding;
466
- return binding.kind === "variable" && binding.name === name
467
- ? binding.primed
468
- : getPrimed(env.rest, name);
469
- };
470
-
471
- // Standardize: an opaque name the Action frontend introduces is an anonymous operator, named
472
- // OPAQUE_ when it has no arguments.
473
- const encodeOpaque = (name: string, args: Expr[], env: Env | undefined, mode: Mode) => {
474
- if (args.length === 0 && name.endsWith("#prime"))
475
- return idv(getPrimed(env, name.slice(0, -"#prime".length)));
476
- const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
477
- anonymous.set(anonymousName, args.length);
478
- return idv(
479
- call(
480
- tla(anonymousName),
481
- args.map((arg) => encodeIdv(arg, env, mode)),
482
- ),
483
- );
484
- };
485
-
486
- const encodeExcept = (
487
- expression: Extract<Expr, { kind: "Except" }>,
488
- env: Env | undefined,
489
- mode: Mode,
490
- ) =>
491
- expression.specs.reduce(
492
- (base, spec) => {
493
- // Elab.desugar: @ is the value at the whole trail.
494
- const update = (value: string, trail: typeof spec.trail): string => {
495
- if (trail.length === 0) return encodeIdv(spec.value, env, { ...mode, at: value });
496
- const point = trail[0];
497
- const encodeKey = () =>
498
- point.kind === "Dot"
499
- ? tla(`StrLit_${point.field}`)
500
- : encodeIdv(point.expression, env, mode);
501
- const key = encodeKey();
502
- // Elab.desugar repeats the key in the value it updates, and Flatten counts both.
503
- const inner = update(
504
- `(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
505
- trail.slice(1),
506
- );
507
- return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
508
- };
509
- return update(base, spec.trail);
510
- },
511
- encodeIdv(expression.function, env, mode),
512
- );
377
+ case "Unprimable": {
378
+ const term = encode(encoder, args[0], env, clearPolarity(mode));
379
+ return { ...term, text: `(${UNPRIMABLE} ${term.text})` };
380
+ }
381
+ default: {
382
+ const symbol = BUILTIN_SYMBOLS[builtin];
383
+ if (symbol === undefined) throw new TlaUnsupportedError(`the operator ${builtin}`);
384
+ return wrapIdv(call(symbol, encodeArgs()));
385
+ }
386
+ }
387
+ };
513
388
 
514
- // Standardize names each CASE with no OTHER by a count that tlapm never resets.
515
- const getCaseError = () => {
516
- session.caseErrors++;
517
- const name = `Anon_incomplete_case_error_${session.caseErrors}`;
518
- anonymous.set(name, 0);
519
- return tla(name);
520
- };
521
-
522
- const encodeCase = (
523
- expression: Extract<Expr, { kind: "Case" }>,
524
- env: Env | undefined,
525
- mode: Mode,
526
- ): Term => {
527
- const bodies = expression.arms.map((arm) => encode(arm.body, env, mode));
528
- // Standardize: a CASE with no OTHER ends in an unknown value.
529
- const other: Term = expression.other
530
- ? encode(expression.other, env, mode)
531
- : idv(getCaseError());
532
- const isBool = other.isBool && bodies.every((body) => body.isBool);
533
- const isInteger =
534
- other.integer !== undefined && bodies.every((body) => body.integer !== undefined);
535
- if (isInteger) {
536
- const integer = expression.arms.reduceRight(
537
- (rest, arm, index) =>
538
- `(ite ${encodeBool(arm.condition, env, neither(mode))} ${bodies[index].integer} ${rest})`,
539
- other.integer ?? "",
389
+ const encodeReference = (
390
+ encoder: Encoder,
391
+ binding: Binding,
392
+ args: Expr[],
393
+ env: Env | undefined,
394
+ mode: Mode,
395
+ ): Term => {
396
+ switch (binding.kind) {
397
+ case "constant":
398
+ case "variable":
399
+ if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
400
+ return wrapIdv(binding.symbol);
401
+ case "operator":
402
+ if (args.length !== binding.arity)
403
+ throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
404
+ return wrapIdv(
405
+ call(
406
+ binding.symbol,
407
+ args.map((arg) => encodeIdv(encoder, arg, env, mode)),
408
+ ),
409
+ );
410
+ case "secondOrder": {
411
+ if (args.length !== binding.shapes.length)
412
+ throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
413
+ const operands = args.map((arg, index) => {
414
+ if (binding.shapes[index] === 0)
415
+ return { isFirstOrder: true, text: encodeIdv(encoder, arg, env, mode) };
416
+ if (arg.kind === "Ix") {
417
+ const argument = getBinding(env, arg.index);
418
+ if (argument.kind !== "operator")
419
+ throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
420
+ return { isFirstOrder: false, text: argument.symbol };
421
+ }
422
+ if (arg.kind !== "Lambda")
423
+ throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
424
+ const bound = bindVariables(
425
+ arg.params.map((param) => param.name),
426
+ env,
427
+ clearPolarity(mode),
428
+ );
429
+ return { isFirstOrder: false, text: encodeIdv(encoder, arg.body, bound.env, bound.mode) };
430
+ });
431
+ const firstOrder = operands.flatMap((operand) =>
432
+ operand.isFirstOrder ? [operand.text] : [],
433
+ );
434
+ const higherOrder = operands.flatMap((operand) =>
435
+ operand.isFirstOrder ? [] : [operand.text],
540
436
  );
541
- return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
437
+ const free = getFree(higherOrder.join(" "), mode.depth);
438
+ const symbol = encoder.flattener.flatten(
439
+ "",
440
+ higherOrder.join(" "),
441
+ mode,
442
+ () => [],
443
+ firstOrder.length + free.length,
444
+ binding.name,
445
+ );
446
+ return wrapIdv(call(symbol, [...firstOrder, ...free]));
542
447
  }
543
- const convert = (term: Term) => (isBool ? term.text : toIdv(term));
544
- const text = expression.arms.reduceRight(
448
+ case "unsupported":
449
+ throw new TlaUnsupportedError(binding.reason);
450
+ }
451
+ };
452
+
453
+ const getPrimed = (env: Env | undefined, name: string): string => {
454
+ if (!env) throw new TlaUnsupportedError(`a primed declaration that isn't a variable`);
455
+ const binding = env.binding;
456
+ return binding.kind === "variable" && binding.name === name
457
+ ? binding.primed
458
+ : getPrimed(env.rest, name);
459
+ };
460
+
461
+ const encodeOpaque = (
462
+ encoder: Encoder,
463
+ name: string,
464
+ args: Expr[],
465
+ env: Env | undefined,
466
+ mode: Mode,
467
+ ) => {
468
+ if (args.length === 0 && name.endsWith("#prime"))
469
+ return wrapIdv(getPrimed(env, name.slice(0, -"#prime".length)));
470
+ const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
471
+ encoder.anonymous.set(anonymousName, args.length);
472
+ return wrapIdv(
473
+ call(
474
+ tla(anonymousName),
475
+ args.map((arg) => encodeIdv(encoder, arg, env, mode)),
476
+ ),
477
+ );
478
+ };
479
+
480
+ const encodeExcept = (
481
+ encoder: Encoder,
482
+ expression: Extract<Expr, { kind: "Except" }>,
483
+ env: Env | undefined,
484
+ mode: Mode,
485
+ ) =>
486
+ expression.specs.reduce(
487
+ (base, spec) => {
488
+ const update = (value: string, trail: typeof spec.trail): string => {
489
+ if (trail.length === 0) return encodeIdv(encoder, spec.value, env, { ...mode, at: value });
490
+ const point = trail[0];
491
+ const encodeKey = () =>
492
+ point.kind === "Dot"
493
+ ? tla(`StrLit_${point.field}`)
494
+ : encodeIdv(encoder, point.expression, env, mode);
495
+ const key = encodeKey();
496
+ // Elab.desugar repeats the key in the value it updates, and Flatten counts both.
497
+ const inner = update(
498
+ `(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
499
+ trail.slice(1),
500
+ );
501
+ return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
502
+ };
503
+ return update(base, spec.trail);
504
+ },
505
+ encodeIdv(encoder, expression.function, env, mode),
506
+ );
507
+
508
+ const getCaseError = (encoder: Encoder) => {
509
+ encoder.session.caseErrors++;
510
+ const name = `Anon_incomplete_case_error_${encoder.session.caseErrors}`;
511
+ encoder.anonymous.set(name, 0);
512
+ return tla(name);
513
+ };
514
+
515
+ const encodeCase = (
516
+ encoder: Encoder,
517
+ expression: Extract<Expr, { kind: "Case" }>,
518
+ env: Env | undefined,
519
+ mode: Mode,
520
+ ): Term => {
521
+ const bodies = expression.arms.map((arm) => encode(encoder, arm.body, env, mode));
522
+ const other: Term = expression.other
523
+ ? encode(encoder, expression.other, env, mode)
524
+ : wrapIdv(getCaseError(encoder));
525
+ const isBool = other.isBool && bodies.every((body) => body.isBool);
526
+ const isInteger =
527
+ other.integer !== undefined && bodies.every((body) => body.integer !== undefined);
528
+ if (isInteger) {
529
+ const integer = expression.arms.reduceRight(
545
530
  (rest, arm, index) =>
546
- `(ite ${encodeBool(arm.condition, env, mode)} ${convert(bodies[index])} ${rest})`,
547
- convert(other),
531
+ `(ite ${encodeBool(encoder, arm.condition, env, clearPolarity(mode))} ${bodies[index].integer} ${rest})`,
532
+ other.integer ?? "",
548
533
  );
549
- return { isBool, text };
550
- };
551
-
552
- const encodeSequent = (sequent: Sequent, env: Env | undefined, mode: Mode): string => {
553
- const steps = sequent.context.reduce<NestedContext>(
554
- (state, hyp) => {
555
- switch (hyp.kind) {
556
- case "Fresh": {
557
- if (hyp.shape > 0) {
558
- if (!state.mode.isOmitted) throw new TlaUnsupportedError("a second-order ASSUME");
559
- const variable = getVariable(hyp.name, state.mode.depth);
560
- return {
561
- env: push(state.env, { kind: "operator", symbol: variable, arity: hyp.shape }),
562
- mode: { ...state.mode, depth: state.mode.depth + 1 },
563
- wrappers: [...state.wrappers, (body) => `(forall ((${variable} Idv)) ${body})`],
564
- };
565
- }
566
- if (hyp.level !== "Constant")
567
- throw new TlaUnsupportedError("a NEW declaration that isn't constant");
568
- const domain = hyp.domain && encodeIdv(hyp.domain, state.env, state.mode);
569
- const bound = bindVariables([hyp.name], state.env, state.mode);
570
- const variable = bound.variables[0];
571
- const guard = domain && `(${MEM} ${variable} ${domain})`;
572
- return {
573
- env: bound.env,
574
- mode: bound.mode,
575
- wrappers: [
576
- ...state.wrappers,
577
- (body) => `(forall ((${variable} Idv)) ${guard ? `(=> ${guard} ${body})` : body})`,
578
- ],
579
- };
580
- }
581
- case "Fact": {
582
- const fact =
583
- hyp.visibility === "Visible"
584
- ? encodeBool(hyp.expression, state.env, invert(state.mode))
585
- : undefined;
534
+ return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
535
+ }
536
+ const convert = (term: Term) => (isBool ? term.text : toIdv(term));
537
+ const text = expression.arms.reduceRight(
538
+ (rest, arm, index) =>
539
+ `(ite ${encodeBool(encoder, arm.condition, env, mode)} ${convert(bodies[index])} ${rest})`,
540
+ convert(other),
541
+ );
542
+ return { isBool, text };
543
+ };
544
+
545
+ const encodeSequent = (
546
+ encoder: Encoder,
547
+ sequent: Sequent,
548
+ env: Env | undefined,
549
+ mode: Mode,
550
+ ): string => {
551
+ const steps = sequent.context.reduce<NestedContext>(
552
+ (state, hyp) => {
553
+ switch (hyp.kind) {
554
+ case "Fresh": {
555
+ if (hyp.shape > 0) {
556
+ if (!state.mode.isOmitted) throw new TlaUnsupportedError("a second-order ASSUME");
557
+ const variable = getVariable(hyp.name, state.mode.depth);
586
558
  return {
587
- env: push(state.env, { kind: "unsupported", reason: "a reference to a fact" }),
588
- mode: state.mode,
589
- wrappers: fact
590
- ? [...state.wrappers, (body) => `(=> ${fact} ${body})`]
591
- : state.wrappers,
559
+ env: push(state.env, { kind: "operator", symbol: variable, arity: hyp.shape }),
560
+ mode: { ...state.mode, depth: state.mode.depth + 1 },
561
+ wrappers: [...state.wrappers, (body) => `(forall ((${variable} Idv)) ${body})`],
592
562
  };
593
563
  }
594
- default:
595
- throw new TlaUnsupportedError(`a ${hyp.kind} in a nested ASSUME`);
564
+ if (hyp.level !== "Constant")
565
+ throw new TlaUnsupportedError("a NEW declaration that isn't constant");
566
+ const domain = hyp.domain && encodeIdv(encoder, hyp.domain, state.env, state.mode);
567
+ const bound = bindVariables([hyp.name], state.env, state.mode);
568
+ const variable = bound.variables[0];
569
+ const guard = domain && `(${MEM} ${variable} ${domain})`;
570
+ return {
571
+ env: bound.env,
572
+ mode: bound.mode,
573
+ wrappers: [
574
+ ...state.wrappers,
575
+ (body) => `(forall ((${variable} Idv)) ${guard ? `(=> ${guard} ${body})` : body})`,
576
+ ],
577
+ };
596
578
  }
597
- },
598
- { env, mode, wrappers: [] },
599
- );
600
- return steps.wrappers.reduceRight(
601
- (body, wrap) => wrap(body),
602
- encodeBool(sequent.active, steps.env, steps.mode),
603
- );
604
- };
605
-
606
- const encode = (expression: Expr, env: Env | undefined, mode: Mode): Term => {
607
- switch (expression.kind) {
608
- case "Ix":
609
- return encodeReference(getBinding(env, expression.index), [], env, mode);
610
- case "Internal":
611
- switch (expression.builtin) {
612
- case "TRUE":
613
- return bool("true");
614
- case "FALSE":
615
- return bool("false");
616
- case "BOOLEAN":
617
- return idv(BOOL_SET);
618
- case "STRING":
619
- return idv(STR_SET);
620
- case "Nat":
621
- return idv(NAT_SET);
622
- case "Int":
623
- return idv(INT_SET);
624
- default:
625
- throw new TlaUnsupportedError(`the operator ${expression.builtin}`);
579
+ case "Fact": {
580
+ const fact =
581
+ hyp.visibility === "Visible"
582
+ ? encodeBool(encoder, hyp.expression, state.env, invert(state.mode))
583
+ : undefined;
584
+ return {
585
+ env: push(state.env, { kind: "unsupported", reason: "a reference to a fact" }),
586
+ mode: state.mode,
587
+ wrappers: fact ? [...state.wrappers, (body) => `(=> ${fact} ${body})`] : state.wrappers,
588
+ };
626
589
  }
627
- case "Apply": {
628
- const operator = expression.operator;
629
- if (operator.kind === "Internal")
630
- return encodeBuiltin(operator.builtin, expression.args, env, mode);
631
- if (operator.kind === "Ix")
632
- return encodeReference(getBinding(env, operator.index), expression.args, env, mode);
633
- if (operator.kind === "Opaque")
634
- return encodeOpaque(operator.name, expression.args, env, mode);
635
- if (operator.kind === "Lambda")
636
- return encode(normalizeApply(operator, expression.args), env, mode);
637
- throw new TlaUnsupportedError(`an application of ${operator.kind}`);
638
- }
639
- case "Sequent":
640
- return bool(encodeSequent(expression.sequent, env, mode));
641
- case "With":
642
- case "Parens":
643
- return encode(expression.expression, env, mode);
644
- case "If": {
645
- const condition = encodeBool(expression.condition, env, mode);
646
- const consequent = encode(expression.consequent, env, mode);
647
- const alternative = encode(expression.alternative, env, mode);
648
- if (consequent.integer !== undefined && alternative.integer !== undefined) {
649
- const integer = `(ite ${resolveTriggers(condition, true)} ${consequent.integer} ${alternative.integer})`;
650
- return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
651
- }
652
- return consequent.isBool && alternative.isBool
653
- ? bool(`(ite ${condition} ${consequent.text} ${alternative.text})`)
654
- : idv(`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`);
655
- }
656
- case "List": {
657
- const items = expression.items.map((item) => encodeBool(item, env, mode));
658
- return bool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
590
+ default:
591
+ throw new TlaUnsupportedError(`a ${hyp.kind} in a nested ASSUME`);
659
592
  }
660
- case "Opaque":
661
- return encodeOpaque(expression.name, [], env, mode);
662
- case "Quant":
663
- return bool(encodeQuantifier(expression, env, mode));
664
- case "Choose":
665
- return encodeChoose(expression, env, mode);
666
- case "SetSt":
667
- return encodeSetSt(expression, env, mode);
668
- case "SetOf":
669
- return encodeSetOf(expression, env, mode);
670
- case "SetEnum":
671
- return idv(
672
- call(
673
- tla(`SetEnum_${expression.elements.length}`),
674
- expression.elements.map((element) => encodeIdv(element, env, mode)),
675
- ),
676
- );
677
- case "Product":
678
- return idv(
679
- call(
680
- tla(`Product_${expression.factors.length}`),
681
- expression.factors.map((factor) => encodeIdv(factor, env, mode)),
682
- ),
683
- );
684
- case "Tuple":
685
- return idv(
686
- call(
687
- tla(`Tuple_${expression.elements.length}`),
688
- expression.elements.map((element) => encodeIdv(element, env, mode)),
689
- ),
690
- );
691
- case "Fcn":
692
- return encodeFunction(expression, env, mode);
693
- // Rewrite.elim_multiarg: f[a, b] applies f to the tuple <<a, b>>.
694
- case "FcnApp": {
695
- const encodedFunction = encodeIdv(expression.function, env, mode);
696
- const args = expression.args.map((arg) => encodeIdv(arg, env, mode));
697
- const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
698
- return idv(`(${FUN_APP} ${encodedFunction} ${argument})`);
593
+ },
594
+ { env, mode, wrappers: [] },
595
+ );
596
+ return steps.wrappers.reduceRight(
597
+ (body, wrap) => wrap(body),
598
+ encodeBool(encoder, sequent.active, steps.env, steps.mode),
599
+ );
600
+ };
601
+
602
+ const encode = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode): Term => {
603
+ switch (expression.kind) {
604
+ case "Ix":
605
+ return encodeReference(encoder, getBinding(env, expression.index), [], env, mode);
606
+ case "Internal":
607
+ switch (expression.builtin) {
608
+ case "TRUE":
609
+ return wrapBool("true");
610
+ case "FALSE":
611
+ return wrapBool("false");
612
+ case "BOOLEAN":
613
+ return wrapIdv(BOOL_SET);
614
+ case "STRING":
615
+ return wrapIdv(STR_SET);
616
+ case "Nat":
617
+ return wrapIdv(NAT_SET);
618
+ case "Int":
619
+ return wrapIdv(INT_SET);
620
+ default:
621
+ throw new TlaUnsupportedError(`the operator ${expression.builtin}`);
699
622
  }
700
- case "Arrow":
701
- return idv(
702
- call(FUN_SET, [
703
- encodeIdv(expression.domain, env, mode),
704
- encodeIdv(expression.range, env, mode),
705
- ]),
706
- );
707
- case "Record":
708
- case "Rect": {
709
- const names = expression.fields.map((field) => field.name);
710
- const suffix = names.join("_");
711
- recordFields.set(`Record_${suffix}`, names);
712
- recordFields.set(`RecordSet_${suffix}`, names);
713
- return idv(
714
- call(
715
- tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
716
- expression.fields.map((field) => encodeIdv(field.value, env, mode)),
717
- ),
623
+ case "Apply": {
624
+ const operator = expression.operator;
625
+ if (operator.kind === "Internal")
626
+ return encodeBuiltin(encoder, operator.builtin, expression.args, env, mode);
627
+ if (operator.kind === "Ix")
628
+ return encodeReference(
629
+ encoder,
630
+ getBinding(env, operator.index),
631
+ expression.args,
632
+ env,
633
+ mode,
718
634
  );
635
+ if (operator.kind === "Opaque")
636
+ return encodeOpaque(encoder, operator.name, expression.args, env, mode);
637
+ if (operator.kind === "Lambda")
638
+ return encode(encoder, normalizeApply(operator, expression.args), env, mode);
639
+ throw new TlaUnsupportedError(`an application of ${operator.kind}`);
640
+ }
641
+ case "Sequent":
642
+ return wrapBool(encodeSequent(encoder, expression.sequent, env, mode));
643
+ case "With":
644
+ case "Parens":
645
+ return encode(encoder, expression.expression, env, mode);
646
+ case "If": {
647
+ const condition = encodeBool(encoder, expression.condition, env, mode);
648
+ const consequent = encode(encoder, expression.consequent, env, mode);
649
+ const alternative = encode(encoder, expression.alternative, env, mode);
650
+ if (consequent.integer !== undefined && alternative.integer !== undefined) {
651
+ const integer = `(ite ${resolveTriggers(condition, true)} ${consequent.integer} ${alternative.integer})`;
652
+ return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
719
653
  }
720
- case "Except":
721
- return idv(encodeExcept(expression, env, mode));
722
- case "Dot":
723
- return idv(
724
- `(${FUN_APP} ${encodeIdv(expression.expression, env, mode)} ${tla(`StrLit_${expression.field}`)})`,
725
- );
726
- case "Case":
727
- return encodeCase(expression, env, mode);
728
- case "String":
729
- return idv(tla(`StrLit_${expression.value}`));
730
- case "Num":
731
- if (expression.fraction !== "") throw new TlaUnsupportedError("a real number");
732
- return {
733
- isBool: false,
734
- text: `(${CAST_INT} ${BigInt(expression.integer)})`,
735
- integer: String(BigInt(expression.integer)),
736
- };
737
- case "At":
738
- if (mode.at === undefined) throw new TlaUnsupportedError("@ outside EXCEPT");
739
- return idv(mode.at);
740
- case "Tquant":
741
- case "Tsub":
742
- case "Fair":
743
- throw new TlaUnsupportedError("a temporal formula");
744
- default:
745
- throw new TlaUnsupportedError(`the expression ${expression.kind}`);
654
+ return consequent.isBool && alternative.isBool
655
+ ? wrapBool(`(ite ${condition} ${consequent.text} ${alternative.text})`)
656
+ : wrapIdv(`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`);
657
+ }
658
+ case "List": {
659
+ const items = expression.items.map((item) => encodeBool(encoder, item, env, mode));
660
+ return wrapBool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
746
661
  }
747
- };
748
-
749
- // One fact or the goal, after the declarations of the symbols it flattens.
750
- const getEntries = (line: string): Entry[] => [
751
- ...flattener.takeIntroduced(),
752
- removeUnprimable(resolveTriggers(line, false)),
753
- ];
754
-
755
- return {
756
- encodeIdv,
757
- encodeBool,
758
- push,
759
- getEntries,
760
- getUniqueName,
761
- flattened: flattener.flattened,
762
- anonymous,
763
- recordFields,
764
- declared,
765
- };
662
+ case "Opaque":
663
+ return encodeOpaque(encoder, expression.name, [], env, mode);
664
+ case "Quant":
665
+ return wrapBool(encodeQuantifier(encoder, expression, env, mode));
666
+ case "Choose":
667
+ return encodeChoose(encoder, expression, env, mode);
668
+ case "SetSt":
669
+ return encodeSetSt(encoder, expression, env, mode);
670
+ case "SetOf":
671
+ return encodeSetOf(encoder, expression, env, mode);
672
+ case "SetEnum":
673
+ return wrapIdv(
674
+ call(
675
+ tla(`SetEnum_${expression.elements.length}`),
676
+ expression.elements.map((element) => encodeIdv(encoder, element, env, mode)),
677
+ ),
678
+ );
679
+ case "Product":
680
+ return wrapIdv(
681
+ call(
682
+ tla(`Product_${expression.factors.length}`),
683
+ expression.factors.map((factor) => encodeIdv(encoder, factor, env, mode)),
684
+ ),
685
+ );
686
+ case "Tuple":
687
+ return wrapIdv(
688
+ call(
689
+ tla(`Tuple_${expression.elements.length}`),
690
+ expression.elements.map((element) => encodeIdv(encoder, element, env, mode)),
691
+ ),
692
+ );
693
+ case "Fcn":
694
+ return encodeFunction(encoder, expression, env, mode);
695
+ case "FcnApp": {
696
+ const encodedFunction = encodeIdv(encoder, expression.function, env, mode);
697
+ const args = expression.args.map((arg) => encodeIdv(encoder, arg, env, mode));
698
+ const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
699
+ return wrapIdv(`(${FUN_APP} ${encodedFunction} ${argument})`);
700
+ }
701
+ case "Arrow":
702
+ return wrapIdv(
703
+ call(FUN_SET, [
704
+ encodeIdv(encoder, expression.domain, env, mode),
705
+ encodeIdv(encoder, expression.range, env, mode),
706
+ ]),
707
+ );
708
+ case "Record":
709
+ case "Rect": {
710
+ const names = expression.fields.map((field) => field.name);
711
+ const suffix = names.join("_");
712
+ encoder.recordFields.set(`Record_${suffix}`, names);
713
+ encoder.recordFields.set(`RecordSet_${suffix}`, names);
714
+ return wrapIdv(
715
+ call(
716
+ tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
717
+ expression.fields.map((field) => encodeIdv(encoder, field.value, env, mode)),
718
+ ),
719
+ );
720
+ }
721
+ case "Except":
722
+ return wrapIdv(encodeExcept(encoder, expression, env, mode));
723
+ case "Dot":
724
+ return wrapIdv(
725
+ `(${FUN_APP} ${encodeIdv(encoder, expression.expression, env, mode)} ${tla(`StrLit_${expression.field}`)})`,
726
+ );
727
+ case "Case":
728
+ return encodeCase(encoder, expression, env, mode);
729
+ case "String":
730
+ return wrapIdv(tla(`StrLit_${expression.value}`));
731
+ case "Num":
732
+ if (expression.fraction !== "") throw new TlaUnsupportedError("a real number");
733
+ return {
734
+ isBool: false,
735
+ text: `(${CAST_INT} ${BigInt(expression.integer)})`,
736
+ integer: String(BigInt(expression.integer)),
737
+ };
738
+ case "At":
739
+ if (mode.at === undefined) throw new TlaUnsupportedError("@ outside EXCEPT");
740
+ return wrapIdv(mode.at);
741
+ case "Tquant":
742
+ case "Tsub":
743
+ case "Fair":
744
+ throw new TlaUnsupportedError("a temporal formula");
745
+ default:
746
+ throw new TlaUnsupportedError(`the expression ${expression.kind}`);
747
+ }
766
748
  };
749
+
750
+ export const getEntries = (encoder: Encoder, line: string): Entry[] => [
751
+ ...encoder.flattener.takeIntroduced(),
752
+ removeUnprimable(resolveTriggers(line, false)),
753
+ ];
754
+
755
+ export const createEncoder = (session: EncodingSession): Encoder => ({
756
+ session,
757
+ flattener: createFlattener(),
758
+ anonymous: new Map(),
759
+ recordFields: new Map(),
760
+ context: createContext(),
761
+ declared: new Map(),
762
+ });