tla-ts 0.0.9 → 0.0.10-dev.06b481ee0

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 (631) hide show
  1. package/README.md +30 -1
  2. package/dist/compile.cjs +23 -0
  3. package/dist/compile.js +23 -0
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +48 -44
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +122 -12
  8. package/dist/index.d.ts +122 -12
  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 +2746 -410
  15. package/dist/prove.js +2745 -409
  16. package/dist/run.cjs +144 -31
  17. package/dist/run.js +144 -31
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +134 -104
  21. package/dist/transfer.js +134 -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 +56 -60
  26. package/src/bags.ts +128 -110
  27. package/src/builtins.ts +31 -77
  28. package/src/bundled-modules.ts +1 -8
  29. package/src/check-failure.ts +118 -0
  30. package/src/check-trace.ts +320 -0
  31. package/src/check.ts +1156 -888
  32. package/src/cli/options.ts +12 -32
  33. package/src/cli/run.ts +0 -2
  34. package/src/cli/runtime-invariants.ts +100 -0
  35. package/src/cli/shared.ts +19 -12
  36. package/src/cli/tlapm.ts +433 -82
  37. package/src/cli/tlc-arguments.ts +652 -0
  38. package/src/cli/tlc-output.ts +701 -0
  39. package/src/cli/tlc-usage.ts +360 -0
  40. package/src/cli/tlc.ts +330 -659
  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 +217 -82
  45. package/src/config.ts +140 -109
  46. package/src/coverage.ts +1019 -0
  47. package/src/dependencies.ts +101 -66
  48. package/src/dfid.ts +683 -0
  49. package/src/environment-config.ts +315 -0
  50. package/src/environment.ts +263 -370
  51. package/src/errors.ts +107 -57
  52. package/src/evaluate.ts +898 -369
  53. package/src/exit-codes.ts +63 -13
  54. package/src/fingerprints.ts +75 -11
  55. package/src/index.ts +3 -0
  56. package/src/instances.ts +137 -22
  57. package/src/java-hash.ts +21 -0
  58. package/src/java-overrides.ts +6 -21
  59. package/src/json-reader.ts +455 -0
  60. package/src/json.ts +252 -139
  61. package/src/levels.ts +231 -154
  62. package/src/lexer.ts +83 -101
  63. package/src/liveness-checker.ts +743 -322
  64. package/src/liveness.ts +230 -133
  65. package/src/obligations/action.ts +17 -44
  66. package/src/obligations/anonymize.ts +120 -95
  67. package/src/obligations/enabled-axioms.ts +218 -0
  68. package/src/obligations/equality.ts +1 -3
  69. package/src/obligations/expression.ts +37 -26
  70. package/src/obligations/format.ts +0 -10
  71. package/src/obligations/generate.ts +66 -64
  72. package/src/obligations/index.ts +39 -20
  73. package/src/obligations/levels.ts +27 -18
  74. package/src/obligations/module.ts +28 -55
  75. package/src/obligations/normalize.ts +31 -41
  76. package/src/obligations/operators.ts +0 -3
  77. package/src/obligations/pragma.ts +52 -24
  78. package/src/obligations/printer.ts +94 -63
  79. package/src/obligations/proof.ts +3 -6
  80. package/src/obligations/regroup.ts +0 -5
  81. package/src/obligations/simplify.ts +57 -63
  82. package/src/obligations/source.ts +121 -95
  83. package/src/obligations/subexpression.ts +49 -28
  84. package/src/obligations/substitution.ts +1 -5
  85. package/src/obligations/temporal.ts +12 -20
  86. package/src/obligations/tuples.ts +2 -10
  87. package/src/parallel-worker.ts +36 -60
  88. package/src/parallel.ts +64 -73
  89. package/src/parser.ts +1184 -531
  90. package/src/pcal/ast.ts +53 -86
  91. package/src/pcal/parse.ts +144 -219
  92. package/src/pcal/tokenize.ts +91 -131
  93. package/src/pcal/translate.ts +83 -130
  94. package/src/pcal/validate.ts +48 -68
  95. package/src/pretty-print.ts +7 -8
  96. package/src/prover/decide-pool.ts +8 -13
  97. package/src/prover/deciders.ts +12 -13
  98. package/src/prover/first-order.ts +0 -11
  99. package/src/prover/isabelle/decide.ts +3 -31
  100. package/src/prover/isabelle/encode.ts +82 -64
  101. package/src/prover/isabelle/isar/attrib.ts +250 -0
  102. package/src/prover/isabelle/isar/context.ts +335 -0
  103. package/src/prover/isabelle/isar/induct.ts +382 -0
  104. package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
  105. package/src/prover/isabelle/isar/method.ts +510 -226
  106. package/src/prover/isabelle/isar/proof.ts +570 -23
  107. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  108. package/src/prover/isabelle/isar/theory.ts +488 -88
  109. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  110. package/src/prover/isabelle/isar/type-check.ts +99 -38
  111. package/src/prover/isabelle/provers/blast/blast.ts +16 -105
  112. package/src/prover/isabelle/provers/blast/branch.ts +0 -33
  113. package/src/prover/isabelle/provers/blast/prove.ts +0 -36
  114. package/src/prover/isabelle/provers/blast/rules.ts +5 -45
  115. package/src/prover/isabelle/provers/blast/state.ts +1 -29
  116. package/src/prover/isabelle/provers/blast/term.ts +8 -37
  117. package/src/prover/isabelle/provers/clasimp.ts +1 -15
  118. package/src/prover/isabelle/provers/classical.ts +58 -61
  119. package/src/prover/isabelle/provers/hypsubst.ts +29 -54
  120. package/src/prover/isabelle/pure/bicompose.ts +24 -39
  121. package/src/prover/isabelle/pure/consts.ts +0 -8
  122. package/src/prover/isabelle/pure/conv.ts +2 -18
  123. package/src/prover/isabelle/pure/drule.ts +95 -45
  124. package/src/prover/isabelle/pure/envir.ts +2 -53
  125. package/src/prover/isabelle/pure/goal.ts +1 -9
  126. package/src/prover/isabelle/pure/interrupt.ts +0 -5
  127. package/src/prover/isabelle/pure/list.ts +0 -3
  128. package/src/prover/isabelle/pure/logic.ts +1 -16
  129. package/src/prover/isabelle/pure/name.ts +1 -10
  130. package/src/prover/isabelle/pure/net.ts +2 -60
  131. package/src/prover/isabelle/pure/object-logic.ts +15 -16
  132. package/src/prover/isabelle/pure/pattern.ts +1 -20
  133. package/src/prover/isabelle/pure/raw-simplifier.ts +16 -63
  134. package/src/prover/isabelle/pure/rewriter.ts +34 -77
  135. package/src/prover/isabelle/pure/search.ts +2 -11
  136. package/src/prover/isabelle/pure/seq.ts +0 -11
  137. package/src/prover/isabelle/pure/simplifier.ts +27 -16
  138. package/src/prover/isabelle/pure/table.ts +2 -33
  139. package/src/prover/isabelle/pure/tactic.ts +11 -23
  140. package/src/prover/isabelle/pure/tactical.ts +47 -48
  141. package/src/prover/isabelle/pure/term-ord.ts +1 -7
  142. package/src/prover/isabelle/pure/term.ts +4 -47
  143. package/src/prover/isabelle/pure/thm.ts +26 -48
  144. package/src/prover/isabelle/pure/type.ts +1 -16
  145. package/src/prover/isabelle/pure/unify.ts +19 -31
  146. package/src/prover/isabelle/pure/variable.ts +2 -8
  147. package/src/prover/isabelle/tla/classical-setup.ts +17 -25
  148. package/src/prover/isabelle/tla/context.ts +65 -26
  149. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  150. package/src/prover/isabelle/tla/logic.ts +53 -32
  151. package/src/prover/isabelle/tla/simpdata.ts +45 -44
  152. package/src/prover/isabelle/tools/intuitionistic.ts +28 -21
  153. package/src/prover/ocaml.ts +4 -7
  154. package/src/prover/prep/action.ts +33 -66
  155. package/src/prover/prep/enabled-axioms.ts +22 -20
  156. package/src/prover/prep/fingerprint.ts +2 -21
  157. package/src/prover/prep/level-comparison.ts +8 -12
  158. package/src/prover/prep/md5.ts +26 -31
  159. package/src/prover/prep/methods.ts +189 -86
  160. package/src/prover/prep/normalize.ts +42 -37
  161. package/src/prover/prove-worker.ts +0 -2
  162. package/src/prover/prove.ts +398 -133
  163. package/src/prover/ptl/decide.ts +96 -56
  164. package/src/prover/ptl/encode.ts +15 -38
  165. package/src/prover/ptl/sat.ts +24 -32
  166. package/src/prover/ptl/tableau.ts +40 -28
  167. package/src/prover/smt/arithmetic.ts +310 -0
  168. package/src/prover/smt/axioms.ts +12 -15
  169. package/src/prover/smt/context.ts +60 -32
  170. package/src/prover/smt/data.ts +517 -401
  171. package/src/prover/smt/encode.ts +155 -85
  172. package/src/prover/smt/extensionality.ts +5 -13
  173. package/src/prover/smt/flatten.ts +7 -28
  174. package/src/prover/smt/format.ts +33 -14
  175. package/src/prover/smt/instances.ts +7 -11
  176. package/src/prover/smt/layout.ts +91 -0
  177. package/src/prover/smt/rewrite.ts +1021 -658
  178. package/src/prover/smt/simplify.ts +441 -0
  179. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  180. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  181. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  182. package/src/prover/smt/solver/act-cache.ts +0 -16
  183. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  184. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  185. package/src/prover/smt/solver/aig.ts +889 -0
  186. package/src/prover/smt/solver/arith-rewriter.ts +626 -56
  187. package/src/prover/smt/solver/arith-terms.ts +121 -0
  188. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  189. package/src/prover/smt/solver/array-rewriter.ts +319 -0
  190. package/src/prover/smt/solver/array.ts +1 -3
  191. package/src/prover/smt/solver/asserted-formulas.ts +241 -99
  192. package/src/prover/smt/solver/ast-lt.ts +165 -21
  193. package/src/prover/smt/solver/ast-util.ts +160 -7
  194. package/src/prover/smt/solver/ast.ts +1480 -184
  195. package/src/prover/smt/solver/auf-solver.ts +30 -56
  196. package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
  197. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  198. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  199. package/src/prover/smt/solver/bound-manager.ts +196 -0
  200. package/src/prover/smt/solver/bound-simplifier.ts +598 -0
  201. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  202. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  203. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  204. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  205. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  206. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  207. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  208. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  209. package/src/prover/smt/solver/card2bv.ts +127 -0
  210. package/src/prover/smt/solver/case-split-queue.ts +0 -10
  211. package/src/prover/smt/solver/cg-table.ts +39 -42
  212. package/src/prover/smt/solver/check-logic.ts +330 -0
  213. package/src/prover/smt/solver/clause.ts +0 -27
  214. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
  215. package/src/prover/smt/solver/conflict-resolution.ts +78 -11
  216. package/src/prover/smt/solver/context.ts +600 -187
  217. package/src/prover/smt/solver/ctx-simplify.ts +34 -52
  218. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  219. package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
  220. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  221. package/src/prover/smt/solver/demodulator.ts +786 -0
  222. package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
  223. package/src/prover/smt/solver/der.ts +39 -30
  224. package/src/prover/smt/solver/diff-neq.ts +205 -0
  225. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  226. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  227. package/src/prover/smt/solver/dt2bv-tactic.ts +296 -0
  228. package/src/prover/smt/solver/dyn-ack.ts +0 -11
  229. package/src/prover/smt/solver/e-matching.ts +9 -41
  230. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  231. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  232. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  233. package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
  234. package/src/prover/smt/solver/enode.ts +100 -23
  235. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  236. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  237. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  238. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  239. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  240. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  241. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  242. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  243. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  244. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  245. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  246. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  247. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  248. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  249. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  250. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  251. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  252. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  253. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  254. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  255. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  256. package/src/prover/smt/solver/expr-ref.ts +0 -5
  257. package/src/prover/smt/solver/expr-safe-replace.ts +26 -7
  258. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  259. package/src/prover/smt/solver/factor.ts +163 -0
  260. package/src/prover/smt/solver/fd-solver.ts +734 -0
  261. package/src/prover/smt/solver/fingerprints.ts +15 -26
  262. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  263. package/src/prover/smt/solver/flat-literals.ts +0 -9
  264. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  265. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  266. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  267. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  268. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  269. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  270. package/src/prover/smt/solver/goal.ts +179 -28
  271. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  272. package/src/prover/smt/solver/guard-set.ts +219 -0
  273. package/src/prover/smt/solver/hash.ts +0 -9
  274. package/src/prover/smt/solver/hashtable.ts +30 -23
  275. package/src/prover/smt/solver/inf-eps.ts +63 -0
  276. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  277. package/src/prover/smt/solver/internalizer.ts +113 -133
  278. package/src/prover/smt/solver/lackr.ts +381 -0
  279. package/src/prover/smt/solver/lbool.ts +0 -2
  280. package/src/prover/smt/solver/lia2card.ts +268 -0
  281. package/src/prover/smt/solver/lia2pb.ts +154 -0
  282. package/src/prover/smt/solver/literal.ts +0 -4
  283. package/src/prover/smt/solver/logic-tactics.ts +355 -0
  284. package/src/prover/smt/solver/lp/bound-propagator.ts +7 -26
  285. package/src/prover/smt/solver/lp/constraints.ts +1 -8
  286. package/src/prover/smt/solver/lp/containers.ts +18 -31
  287. package/src/prover/smt/solver/lp/core-solver.ts +35 -37
  288. package/src/prover/smt/solver/lp/cross-nested.ts +4 -21
  289. package/src/prover/smt/solver/lp/dep-intervals.ts +6 -24
  290. package/src/prover/smt/solver/lp/dependency.ts +0 -5
  291. package/src/prover/smt/solver/lp/dioph-eq.ts +8 -103
  292. package/src/prover/smt/solver/lp/explanation.ts +0 -6
  293. package/src/prover/smt/solver/lp/gomory.ts +8 -22
  294. package/src/prover/smt/solver/lp/hnf-cutter.ts +16 -23
  295. package/src/prover/smt/solver/lp/hnf.ts +10 -28
  296. package/src/prover/smt/solver/lp/int-cube.ts +17 -39
  297. package/src/prover/smt/solver/lp/int-solver.ts +3 -35
  298. package/src/prover/smt/solver/lp/lar-solver.ts +70 -83
  299. package/src/prover/smt/solver/lp/lar-term.ts +0 -5
  300. package/src/prover/smt/solver/lp/lp-settings.ts +6 -16
  301. package/src/prover/smt/solver/lp/maximize-term.ts +76 -52
  302. package/src/prover/smt/solver/lp/nex-creator.ts +7 -30
  303. package/src/prover/smt/solver/lp/nex.ts +2 -7
  304. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -5
  305. package/src/prover/smt/solver/lp/nla-basics.ts +48 -30
  306. package/src/prover/smt/solver/lp/nla-core.ts +92 -136
  307. package/src/prover/smt/solver/lp/nla-divisions.ts +31 -43
  308. package/src/prover/smt/solver/lp/nla-emonics.ts +3 -21
  309. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -4
  310. package/src/prover/smt/solver/lp/nla-grobner.ts +177 -149
  311. package/src/prover/smt/solver/lp/nla-horner.ts +2 -12
  312. package/src/prover/smt/solver/lp/nla-intervals.ts +1 -12
  313. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +15 -42
  314. package/src/prover/smt/solver/lp/nla-monotone.ts +1 -6
  315. package/src/prover/smt/solver/lp/nla-order.ts +0 -13
  316. package/src/prover/smt/solver/lp/nla-patcher.ts +3 -7
  317. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  318. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -10
  319. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -6
  320. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  321. package/src/prover/smt/solver/lp/nla-types.ts +0 -12
  322. package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -26
  323. package/src/prover/smt/solver/lp/nra-solver.ts +164 -147
  324. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -4
  325. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -5
  326. package/src/prover/smt/solver/lp/pdd-simplifier.ts +61 -34
  327. package/src/prover/smt/solver/lp/pdd-solver.ts +74 -72
  328. package/src/prover/smt/solver/lp/pdd.ts +730 -358
  329. package/src/prover/smt/solver/lp/random-updater.ts +0 -9
  330. package/src/prover/smt/solver/lp/static-matrix.ts +8 -19
  331. package/src/prover/smt/solver/lp/union-find.ts +5 -5
  332. package/src/prover/smt/solver/macro-finder.ts +530 -0
  333. package/src/prover/smt/solver/mam-compiler.ts +129 -139
  334. package/src/prover/smt/solver/mam-interpreter.ts +0 -21
  335. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  336. package/src/prover/smt/solver/max-cliques.ts +105 -0
  337. package/src/prover/smt/solver/maxcore.ts +310 -0
  338. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -21
  339. package/src/prover/smt/solver/maxlex.ts +115 -0
  340. package/src/prover/smt/solver/maxsmt-base.ts +106 -0
  341. package/src/prover/smt/solver/maxsmt.ts +92 -0
  342. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  343. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  344. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  345. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  346. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  347. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  348. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  349. package/src/prover/smt/solver/model-checker.ts +20 -63
  350. package/src/prover/smt/solver/model-evaluator.ts +192 -40
  351. package/src/prover/smt/solver/model-finder.ts +14 -32
  352. package/src/prover/smt/solver/model-generator.ts +104 -46
  353. package/src/prover/smt/solver/model-macro-solver.ts +60 -114
  354. package/src/prover/smt/solver/model-printer.ts +214 -0
  355. package/src/prover/smt/solver/mpf.ts +709 -0
  356. package/src/prover/smt/solver/mus.ts +50 -0
  357. package/src/prover/smt/solver/muz/dl-context.ts +382 -0
  358. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  359. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  360. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  361. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  362. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  363. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  364. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  365. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  366. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  367. package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
  368. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  369. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  370. package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
  371. package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
  372. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  373. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  374. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  375. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  376. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  377. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  378. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  379. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  380. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  381. package/src/prover/smt/solver/nlqsat.ts +484 -0
  382. package/src/prover/smt/solver/nlsat/algebraic.ts +357 -236
  383. package/src/prover/smt/solver/nlsat/atoms.ts +73 -54
  384. package/src/prover/smt/solver/nlsat/evaluator.ts +16 -22
  385. package/src/prover/smt/solver/nlsat/explain.ts +429 -275
  386. package/src/prover/smt/solver/nlsat/interval-set.ts +9 -51
  387. package/src/prover/smt/solver/nlsat/levelwise.ts +477 -344
  388. package/src/prover/smt/solver/nlsat/mpbq.ts +47 -14
  389. package/src/prover/smt/solver/nlsat/polynomial.ts +2385 -832
  390. package/src/prover/smt/solver/nlsat/solver.ts +297 -156
  391. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  392. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  393. package/src/prover/smt/solver/nlsat/types.ts +0 -9
  394. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -51
  395. package/src/prover/smt/solver/nlsat/upolynomial.ts +49 -109
  396. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  397. package/src/prover/smt/solver/nnf.ts +112 -61
  398. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  399. package/src/prover/smt/solver/occf.ts +97 -0
  400. package/src/prover/smt/solver/opt-context.ts +801 -0
  401. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  402. package/src/prover/smt/solver/opt-pareto.ts +301 -0
  403. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  404. package/src/prover/smt/solver/opt-solver.ts +312 -0
  405. package/src/prover/smt/solver/opt-value.ts +55 -0
  406. package/src/prover/smt/solver/optsmt.ts +692 -0
  407. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  408. package/src/prover/smt/solver/pattern-inference.ts +21 -26
  409. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  410. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  411. package/src/prover/smt/solver/poly-rewriter.ts +261 -79
  412. package/src/prover/smt/solver/probes.ts +577 -0
  413. package/src/prover/smt/solver/propagate-values.ts +37 -30
  414. package/src/prover/smt/solver/proto-model.ts +650 -66
  415. package/src/prover/smt/solver/pull-quant.ts +28 -23
  416. package/src/prover/smt/solver/purify-arith.ts +632 -0
  417. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  418. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  419. package/src/prover/smt/solver/qe-lite-der.ts +2 -31
  420. package/src/prover/smt/solver/qe-lite-fm.ts +4 -28
  421. package/src/prover/smt/solver/qe-lite.ts +41 -51
  422. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  423. package/src/prover/smt/solver/qe.ts +1499 -0
  424. package/src/prover/smt/solver/qel.ts +25 -0
  425. package/src/prover/smt/solver/qi-queue.ts +0 -16
  426. package/src/prover/smt/solver/qsat.ts +829 -0
  427. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  428. package/src/prover/smt/solver/quant-tactics.ts +17 -74
  429. package/src/prover/smt/solver/quantifier-analyzer.ts +26 -47
  430. package/src/prover/smt/solver/quantifier-manager.ts +22 -32
  431. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  432. package/src/prover/smt/solver/random-gen.ts +0 -2
  433. package/src/prover/smt/solver/rational.ts +45 -8
  434. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  435. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  436. package/src/prover/smt/solver/reduce-args.ts +225 -0
  437. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  438. package/src/prover/smt/solver/ref-vector.ts +0 -6
  439. package/src/prover/smt/solver/relevancy.ts +2 -16
  440. package/src/prover/smt/solver/rewriter-tpl.ts +59 -135
  441. package/src/prover/smt/solver/rewriter.ts +507 -144
  442. package/src/prover/smt/solver/rlimit.ts +46 -24
  443. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  444. package/src/prover/smt/solver/sat/big.ts +177 -0
  445. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  446. package/src/prover/smt/solver/sat/clause.ts +203 -0
  447. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  448. package/src/prover/smt/solver/sat/config.ts +122 -0
  449. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  450. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  451. package/src/prover/smt/solver/sat/goal2sat.ts +579 -0
  452. package/src/prover/smt/solver/sat/inc-sat-solver.ts +464 -0
  453. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  454. package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
  455. package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
  456. package/src/prover/smt/solver/sat/probing.ts +170 -0
  457. package/src/prover/smt/solver/sat/sat-tactic.ts +53 -0
  458. package/src/prover/smt/solver/sat/sat2goal.ts +189 -0
  459. package/src/prover/smt/solver/sat/scc.ts +142 -0
  460. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  461. package/src/prover/smt/solver/sat/solver.ts +2107 -0
  462. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  463. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  464. package/src/prover/smt/solver/search-tree.ts +284 -0
  465. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  466. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  467. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  468. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  469. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  470. package/src/prover/smt/solver/seq-factory.ts +89 -0
  471. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  472. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  473. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  474. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  475. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  476. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  477. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  478. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  479. package/src/prover/smt/solver/seq-subset.ts +165 -0
  480. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  481. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  482. package/src/prover/smt/solver/smt-kernel.ts +124 -0
  483. package/src/prover/smt/solver/smt-logics.ts +66 -0
  484. package/src/prover/smt/solver/smt-setup.ts +589 -0
  485. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  486. package/src/prover/smt/solver/smtlib-parser.ts +3546 -406
  487. package/src/prover/smt/solver/smtlib-script.ts +2134 -0
  488. package/src/prover/smt/solver/solve-eqs.ts +928 -0
  489. package/src/prover/smt/solver/solver.ts +135 -40
  490. package/src/prover/smt/solver/sort.ts +1 -5
  491. package/src/prover/smt/solver/static-features.ts +314 -0
  492. package/src/prover/smt/solver/sticky-generations.ts +0 -6
  493. package/src/prover/smt/solver/tactic.ts +2141 -0
  494. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  495. package/src/prover/smt/solver/theory-array.ts +1240 -0
  496. package/src/prover/smt/solver/theory-bv.ts +1210 -0
  497. package/src/prover/smt/solver/theory-char.ts +355 -0
  498. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  499. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  500. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  501. package/src/prover/smt/solver/theory-lra-axioms.ts +55 -25
  502. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -11
  503. package/src/prover/smt/solver/theory-lra-final-check.ts +60 -91
  504. package/src/prover/smt/solver/theory-lra-internalize.ts +96 -53
  505. package/src/prover/smt/solver/theory-lra-model.ts +23 -53
  506. package/src/prover/smt/solver/theory-lra-propagate.ts +34 -42
  507. package/src/prover/smt/solver/theory-lra-state.ts +7 -28
  508. package/src/prover/smt/solver/theory-lra.ts +189 -9
  509. package/src/prover/smt/solver/theory-pb.ts +951 -0
  510. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  511. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  512. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  513. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  514. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  515. package/src/prover/smt/solver/theory-seq.ts +961 -0
  516. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  517. package/src/prover/smt/solver/theory.ts +189 -0
  518. package/src/prover/smt/solver/tseitin-cnf.ts +486 -0
  519. package/src/prover/smt/solver/var-subst.ts +37 -39
  520. package/src/prover/smt/table.ts +3 -10
  521. package/src/prover/smt/types.ts +146 -0
  522. package/src/prover/tlapm/cache.ts +74 -48
  523. package/src/prover/tlapm/ocaml-marshal.ts +19 -21
  524. package/src/prover/tlapm/tlapm.ts +21 -20
  525. package/src/prover/tlapm-library.ts +3208 -0
  526. package/src/prover/verdict.ts +9 -2
  527. package/src/prover/zenon/check/check.ts +1 -11
  528. package/src/prover/zenon/check/definitions.ts +5 -15
  529. package/src/prover/zenon/check/equality.ts +0 -8
  530. package/src/prover/zenon/check/functions.ts +0 -4
  531. package/src/prover/zenon/check/keys.ts +0 -7
  532. package/src/prover/zenon/check/propositional.ts +0 -3
  533. package/src/prover/zenon/check/records.ts +1 -6
  534. package/src/prover/zenon/check/relations.ts +2 -14
  535. package/src/prover/zenon/check/rewrites.ts +2 -21
  536. package/src/prover/zenon/check/sets.ts +40 -61
  537. package/src/prover/zenon/check/terms.ts +1 -19
  538. package/src/prover/zenon/check/tla.ts +0 -6
  539. package/src/prover/zenon/decide.ts +10 -19
  540. package/src/prover/zenon/encode.ts +0 -9
  541. package/src/prover/zenon/eqrel.ts +2 -15
  542. package/src/prover/zenon/equality-rules.ts +24 -6
  543. package/src/prover/zenon/expr.ts +29 -28
  544. package/src/prover/zenon/index-table.ts +33 -61
  545. package/src/prover/zenon/isar-case.ts +9 -21
  546. package/src/prover/zenon/isar.ts +37 -67
  547. package/src/prover/zenon/limits.ts +0 -4
  548. package/src/prover/zenon/llproof.ts +2 -22
  549. package/src/prover/zenon/mltoll.ts +66 -106
  550. package/src/prover/zenon/node.ts +20 -15
  551. package/src/prover/zenon/ocaml.ts +1 -17
  552. package/src/prover/zenon/parse.ts +9 -13
  553. package/src/prover/zenon/phrase.ts +2 -14
  554. package/src/prover/zenon/proof.ts +0 -11
  555. package/src/prover/zenon/propositional-rules.ts +0 -7
  556. package/src/prover/zenon/rules.ts +3 -8
  557. package/src/prover/zenon/search.ts +11 -35
  558. package/src/prover/zenon/tla/functions.ts +59 -33
  559. package/src/prover/zenon/tla/llproof.ts +67 -78
  560. package/src/prover/zenon/tla/records.ts +57 -35
  561. package/src/prover/zenon/tla/rewrites.ts +12 -21
  562. package/src/prover/zenon/tla/sets.ts +88 -59
  563. package/src/prover/zenon/tla/terms.ts +0 -8
  564. package/src/prover/zenon/tla/tla.ts +66 -66
  565. package/src/randomization.ts +81 -35
  566. package/src/resolve.ts +1132 -430
  567. package/src/runtime.ts +33 -23
  568. package/src/sany/builtins.ts +11 -14
  569. package/src/sany/generation.ts +383 -0
  570. package/src/sany/generator-def-entries.ts +210 -0
  571. package/src/sany/generator-definitions.ts +688 -0
  572. package/src/sany/generator-expressions.ts +1108 -0
  573. package/src/sany/generator-proofs.ts +665 -0
  574. package/src/sany/generator.ts +192 -2764
  575. package/src/sany/levels.ts +5 -35
  576. package/src/sany/lexer.ts +61 -80
  577. package/src/sany/linter.ts +0 -10
  578. package/src/sany/modules.ts +5 -7
  579. package/src/sany/nodes.ts +6 -44
  580. package/src/sany/parse-error.ts +39 -117
  581. package/src/sany/report.ts +32 -69
  582. package/src/sany/selectors.ts +60 -82
  583. package/src/sany/source.ts +1 -17
  584. package/src/sany/xml.ts +37 -120
  585. package/src/search.ts +913 -227
  586. package/src/simulate.ts +765 -0
  587. package/src/spec-description.ts +198 -104
  588. package/src/standard-definitions.ts +4 -4
  589. package/src/standard-modules.ts +302 -99
  590. package/src/state-graph.ts +52 -33
  591. package/src/subexpressions.ts +578 -166
  592. package/src/substitution-levels.ts +7 -7
  593. package/src/successors.ts +299 -108
  594. package/src/symmetry.ts +37 -28
  595. package/src/tableau.ts +29 -26
  596. package/src/tlc/fingerprint.ts +267 -79
  597. package/src/tlc/jar-data.ts +122 -6
  598. package/src/tlc/messages.ts +127 -56
  599. package/src/tlc/order.ts +53 -72
  600. package/src/tlc/random.ts +38 -49
  601. package/src/tlc/replay.ts +579 -230
  602. package/src/tlc/summary.ts +64 -60
  603. package/src/tlc/tlc-operators.ts +83 -47
  604. package/src/tlc/tlcext-operators.ts +205 -127
  605. package/src/tlc/trace-spec.ts +235 -0
  606. package/src/tlc/value-stream.ts +139 -0
  607. package/src/tlc/version.ts +1 -4
  608. package/src/trace-liveness.ts +529 -0
  609. package/src/transfer.ts +22 -25
  610. package/src/typed-tier.ts +6556 -0
  611. package/src/typescript/actions.ts +479 -0
  612. package/src/typescript/collections.ts +614 -0
  613. package/src/typescript/compile.ts +63 -0
  614. package/src/typescript/context.ts +94 -0
  615. package/src/typescript/emit.ts +121 -0
  616. package/src/typescript/expressions.ts +496 -0
  617. package/src/typescript/formula.ts +154 -0
  618. package/src/typescript/functions.ts +284 -0
  619. package/src/typescript/model.ts +162 -0
  620. package/src/typescript/names.ts +114 -0
  621. package/src/typescript/program.ts +48 -0
  622. package/src/typescript/properties.ts +139 -0
  623. package/src/typescript/scope.ts +112 -0
  624. package/src/typescript/steps.ts +167 -0
  625. package/src/typescript/types.ts +171 -0
  626. package/src/values.ts +945 -526
  627. package/src/worker.ts +7 -8
  628. package/src/prover/isabelle/isar/statement.ts +0 -57
  629. package/src/prover/smt/solver/z3-license.txt +0 -10
  630. package/src/prover/tlaps-module.ts +0 -510
  631. package/src/prover/zenon/LICENSE +0 -32
@@ -1,19 +1,9 @@
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
- import { TlaUnsupportedError } from "../../errors";
1
+ import { TlaError, TlaProverError, 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, Hyp, Sequent } from "../../obligations/expression";
4
+ import { getNumeral } from "./axioms";
8
5
  import { createContext, type Identifier } from "./context";
9
- import {
10
- createFlattener,
11
- getDepth,
12
- getVariable,
13
- removeUnprimable,
14
- UNPRIMABLE,
15
- type Entry,
16
- } from "./flatten";
6
+ import { createFlattener, getDepth, removeUnprimable, UNPRIMABLE, type Entry } from "./flatten";
17
7
  import {
18
8
  BOOL_SET,
19
9
  BUILTIN_SYMBOLS,
@@ -24,18 +14,21 @@ import {
24
14
  disjoin,
25
15
  FUN_APP,
26
16
  FUN_EXCEPT,
17
+ FUN_ISAFCN,
27
18
  FUN_SET,
28
19
  getBinders,
20
+ getVariable,
21
+ getVariableSort,
29
22
  INT_LTEQ,
30
23
  INT_SET,
31
24
  MEM,
32
25
  NAT_SET,
26
+ PROJ_INT,
33
27
  STR_SET,
34
28
  SUBSET_EQ,
35
29
  tla,
36
30
  TT_IDV,
37
31
  } from "./format";
38
- import { getIntegers } from "./axioms";
39
32
  import { getEquality, resolveTriggers, type Polarity } from "./extensionality";
40
33
  import {
41
34
  getChooseAxioms,
@@ -44,21 +37,39 @@ import {
44
37
  getSetOfAxioms,
45
38
  getSetStAxioms,
46
39
  } from "./instances";
40
+ import {
41
+ BOOL,
42
+ getSort,
43
+ getTypeName,
44
+ IDV,
45
+ INT,
46
+ isSameType,
47
+ searchType,
48
+ STRING,
49
+ type Type,
50
+ } from "./types";
47
51
 
48
52
  interface Term {
49
53
  isBool: boolean;
50
54
  text: string;
51
- // Type.Synthesize: the Int-sorted form of a term that is an integer before it's cast to Idv.
52
55
  integer?: string;
56
+ type?: Type;
53
57
  }
54
58
 
55
- // What tlapm keeps across the obligations of one run.
56
59
  export interface EncodingSession {
57
60
  caseErrors: number;
58
61
  }
59
62
 
63
+ // The options of Smtlib.preprocess that tlapm's --debug flags set.
64
+ export interface SmtEncoding {
65
+ isArithmetic: boolean;
66
+ rewriteLevel: number;
67
+ isSetExtensional: boolean;
68
+ // Type level 2, which --debug smarter_types turns on.
69
+ isTyped: boolean;
70
+ }
71
+
60
72
  export interface Mode {
61
- // Whether the text encodes a fact that tlapm leaves out, which may declare operators.
62
73
  isOmitted: boolean;
63
74
  polarity: Polarity;
64
75
  at: string | undefined;
@@ -66,8 +77,15 @@ export interface Mode {
66
77
  }
67
78
 
68
79
  export type Binding =
69
- | { kind: "constant"; symbol: string }
70
- | { kind: "variable"; name: string; symbol: string; primed: string }
80
+ | { kind: "constant"; symbol: string; type?: Type }
81
+ | {
82
+ kind: "variable";
83
+ name: string;
84
+ symbol: string;
85
+ primed: string;
86
+ type?: Type;
87
+ primedType?: Type;
88
+ }
71
89
  | { kind: "operator"; symbol: string; arity: number }
72
90
  | { kind: "secondOrder"; name: string; shapes: number[] }
73
91
  | { kind: "unsupported"; reason: string };
@@ -77,690 +95,1035 @@ export interface Env {
77
95
  rest: Env | undefined;
78
96
  }
79
97
 
80
- // A nested ASSUME's declarations and facts so far: each wraps the goal in a quantifier or an
81
- // implication.
98
+ export interface Encoder {
99
+ session: EncodingSession;
100
+ encoding: SmtEncoding;
101
+ flattener: ReturnType<typeof createFlattener>;
102
+ anonymous: Map<string, number>;
103
+ recordFields: Map<string, string[]>;
104
+ setTypes: Map<string, Type>;
105
+ context: ReturnType<typeof createContext>;
106
+ declared: Map<string, Identifier>;
107
+ }
108
+
82
109
  interface NestedContext {
83
110
  env: Env | undefined;
84
111
  mode: Mode;
85
112
  wrappers: ((body: string) => string)[];
86
113
  }
87
114
 
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
- };
115
+ const UNSUPPORTED_OPERANDS = new Set<Builtin>([
116
+ "Prime",
117
+ "StrongPrime",
118
+ "Leadsto",
119
+ "ENABLED",
120
+ "UNCHANGED",
121
+ "Cdot",
122
+ "Actplus",
123
+ "BoxTrue",
124
+ "BoxFalse",
125
+ "Diamond",
126
+ "Divides",
127
+ "Irregular",
128
+ ]);
119
129
 
120
- const push = (env: Env | undefined, binding: Binding): Env => ({ binding, rest: env });
130
+ const ARITHMETIC = new Set<Builtin>(["Plus", "Minus", "Times", "Uminus"]);
121
131
 
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));
132
+ const getSetType = (element: Type): Type => ({ kind: "Set", element });
127
133
 
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
- };
134
+ const getRecordFieldType = (type: Type, field: string) =>
135
+ type.kind === "Record" ? type.fields.find((entry) => entry.name === field)?.type : undefined;
135
136
 
136
- const neither = (mode: Mode): Mode => ({ ...mode, polarity: "Neither" });
137
+ const getFieldType = (type: Type, field: string) =>
138
+ type.kind === "Fun" && type.domain.kind === "String"
139
+ ? type.range
140
+ : getRecordFieldType(type, field);
137
141
 
138
- const invert = (mode: Mode): Mode => ({
139
- ...mode,
140
- polarity:
141
- mode.polarity === "Positive"
142
- ? "Negative"
143
- : mode.polarity === "Negative"
144
- ? "Positive"
145
- : "Neither",
146
- });
142
+ const getComponentType = (type: Type, args: Expr[]) => {
143
+ if (args.length !== 1) return undefined;
144
+ const arg = args[0];
145
+ if (arg.kind === "String") return getRecordFieldType(type, arg.value);
146
+ return arg.kind === "Num" && arg.fraction === "" && type.kind === "Product"
147
+ ? type.items[Number(arg.integer) - 1]
148
+ : undefined;
149
+ };
147
150
 
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
- };
151
+ const getBuiltinType = (builtin: Builtin, types: Type[]): Type | undefined => {
152
+ const first = types[0];
153
+ switch (builtin) {
154
+ case "Range":
155
+ return getSetType(INT);
156
+ case "Cup":
157
+ case "Cap":
158
+ case "Setminus":
159
+ return first.kind === "Set" && isSameType(first, types[1]) ? first : undefined;
160
+ case "UNION":
161
+ return first.kind === "Set" && first.element.kind === "Set" ? first.element : undefined;
162
+ case "SUBSET":
163
+ return first.kind === "Set" ? getSetType(first) : undefined;
164
+ case "DOMAIN":
165
+ if (first.kind === "Fun") return getSetType(first.domain);
166
+ if (first.kind === "Product") return getSetType(INT);
167
+ return first.kind === "Record" ? getSetType(STRING) : undefined;
168
+ default:
169
+ return undefined;
170
+ }
171
+ };
179
172
 
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
- };
173
+ const toBool = (term: Term) =>
174
+ term.isBool ? term.text : `(= ${resolveTriggers(term.text, true)} ${TT_IDV})`;
199
175
 
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
- };
176
+ const toIdv = (term: Term) =>
177
+ term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
218
178
 
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
- };
179
+ const wrapBool = (text: string): Term => ({ isBool: true, text });
242
180
 
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
- };
181
+ const wrapIdv = (text: string, type?: Type): Term => ({ isBool: false, text, type });
276
182
 
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
- };
183
+ const wrapInteger = (text: string): Term => ({
184
+ isBool: false,
185
+ text: `(${CAST_INT} ${text})`,
186
+ integer: text,
187
+ });
188
+
189
+ const getTypedOnly = (encoder: Encoder, type: Type | undefined) =>
190
+ encoder.encoding.isTyped ? type : undefined;
191
+
192
+ const getType = (term: Term) =>
193
+ term.isBool ? BOOL : term.integer === undefined ? (term.type ?? IDV) : INT;
194
+
195
+ const getTyped = (symbol: string, type: Type | undefined) => {
196
+ if (type?.kind === "Int") return wrapInteger(symbol);
197
+ return type?.kind === "Bool" ? wrapBool(symbol) : wrapIdv(symbol, type);
198
+ };
199
+
200
+ // Type.Synthesize marks a component of a tuple or record as projected into its type, and only
201
+ // Int has a projection at type level 2. tlapm leaves a Bool component an Idv it then uses as a
202
+ // Bool, so it stays an individual here.
203
+ const project = (text: string, type: Type) => {
204
+ if (type.kind === "Int") return { isBool: false, text, integer: `(${PROJ_INT} ${text})` };
205
+ return wrapIdv(text, type.kind === "Bool" ? undefined : type);
206
+ };
207
+
208
+ const getElementType = (term: Term) => {
209
+ const type = getType(term);
210
+ return type.kind === "Set" ? type.element : undefined;
211
+ };
212
+
213
+ const getBinding = (env: Env | undefined, index: number): Binding => {
214
+ const found = Array.from({ length: index - 1 }).reduce<Env | undefined>(
215
+ (current) => current?.rest,
216
+ env,
217
+ );
218
+ if (!found) throw new TlaUnsupportedError("a reference outside the obligation");
219
+ return found.binding;
220
+ };
221
+
222
+ export const push = (env: Env | undefined, binding: Binding): Env => ({ binding, rest: env });
299
223
 
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,
224
+ const inferType = (
225
+ encoder: Encoder,
226
+ expression: Expr,
227
+ env: Env | undefined,
228
+ mode: Mode,
229
+ depth: number,
230
+ ) => {
231
+ const inner = Array.from({ length: depth }).reduce<Env | undefined>(
232
+ (current) => push(current, { kind: "unsupported", reason: "a declaration without a type" }),
233
+ env,
234
+ );
235
+ try {
236
+ return getType(
237
+ encode(
238
+ createEncoder({ caseErrors: encoder.session.caseErrors }, encoder.encoding),
239
+ expression,
240
+ inner,
241
+ mode,
242
+ ),
308
243
  );
244
+ } catch (error) {
245
+ if (error instanceof TlaError) return undefined;
246
+ throw error;
247
+ }
248
+ };
249
+
250
+ // The type a later hypothesis gives a declaration with no domain, which the env doesn't bind yet.
251
+ // A primed variable has no index of its own, so the hypotheses name it.
252
+ export const searchDeclarationType = (
253
+ encoder: Encoder,
254
+ expression: Expr,
255
+ isPositive: boolean,
256
+ env: Env | undefined,
257
+ mode: Mode,
258
+ primed?: string,
259
+ ) =>
260
+ encoder.encoding.isTyped
261
+ ? searchType(
262
+ {
263
+ infer: (inner, depth) =>
264
+ inferType(encoder, inner, env, mode, primed === undefined ? depth + 1 : depth),
265
+ isTarget: (inner, depth) =>
266
+ primed === undefined
267
+ ? inner.kind === "Ix" && inner.index === depth + 1
268
+ : inner.kind === "Opaque" && inner.name === primed,
269
+ },
270
+ isPositive,
271
+ expression,
272
+ )
273
+ : undefined;
274
+
275
+ const getFree = (text: string, depth: number) =>
276
+ [...new Set(text.match(/[^\s()]+#\d+/g))]
277
+ .filter((variable) => getDepth(variable) < depth)
278
+ .toSorted((left, right) => getDepth(left) - getDepth(right));
279
+
280
+ export const getUniqueName = (encoder: Encoder, name: string) => {
281
+ const identifier = encoder.context.adjoin(name);
282
+ encoder.context.enter(identifier);
283
+ encoder.declared.set(identifier.name, identifier);
284
+ return identifier.name;
285
+ };
309
286
 
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,
287
+ const clearPolarity = (mode: Mode): Mode => ({ ...mode, polarity: "Neither" });
288
+
289
+ const invert = (mode: Mode): Mode => ({
290
+ ...mode,
291
+ polarity:
292
+ mode.polarity === "Positive"
293
+ ? "Negative"
294
+ : mode.polarity === "Negative"
295
+ ? "Positive"
296
+ : "Neither",
297
+ });
298
+
299
+ const encodeIdv = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
300
+ toIdv(encode(encoder, expression, env, clearPolarity(mode)));
301
+
302
+ export const encodeBool = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
303
+ toBool(encode(encoder, expression, env, mode));
304
+
305
+ // tlapm's Rewrite encodes each Ditto's copy of a domain, so each copy flattens again.
306
+ const encodeDomains = (encoder: Encoder, bounds: Bound[], env: Env | undefined, mode: Mode) =>
307
+ bounds
308
+ .reduce<(Expr | undefined)[]>((domains, bound) => {
309
+ if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
310
+ if (bound.domain.kind === "NoDomain") return [...domains, undefined];
311
+ return [...domains, bound.domain.expression];
312
+ }, [])
313
+ .map((domain) =>
314
+ domain === undefined ? undefined : encode(encoder, domain, env, clearPolarity(mode)),
323
315
  );
324
- return { body, variable: bound.variables[0] };
325
- };
326
316
 
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,
317
+ const getDomains = (
318
+ encoder: Encoder,
319
+ bounds: Bound[],
320
+ env: Env | undefined,
321
+ mode: Mode,
322
+ construct: string,
323
+ ) =>
324
+ encodeDomains(encoder, bounds, env, mode).map((domain) => {
325
+ if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
326
+ return domain;
327
+ });
328
+
329
+ const getSetResult = (encoder: Encoder, domains: Term[], getResult: (elements: Type[]) => Type) => {
330
+ const elements = domains.map(getElementType);
331
+ return encoder.encoding.isTyped && elements.every((element) => element !== undefined)
332
+ ? getResult(elements.filter((element) => element !== undefined))
333
+ : undefined;
334
+ };
335
+
336
+ const bindVariables = (
337
+ names: string[],
338
+ env: Env | undefined,
339
+ mode: Mode,
340
+ types: (Type | undefined)[] = [],
341
+ ) => {
342
+ const variables = names.map((name, index) =>
343
+ getVariable(name, mode.depth + index, getSort(types[index])),
344
+ );
345
+ const inner = variables.reduce<Env | undefined>(
346
+ (current, symbol, index) => push(current, { kind: "constant", symbol, type: types[index] }),
347
+ env,
348
+ );
349
+ return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
350
+ };
351
+
352
+ // Type.Synthesize types a variable bounded by a set of type Set(t) as a t. A Ditto has the
353
+ // previous domain, though tlapm types it without a cast in its membership, or as Set(t) itself
354
+ // when t isn't atomic, so Z3 rejects either. A variable with no domain gets the type a hypothesis
355
+ // in the rest of the quantifier gives it.
356
+ const getBoundTypes = (
357
+ encoder: Encoder,
358
+ expression: Extract<Expr, { kind: "Quant" }>,
359
+ domains: (Term | undefined)[],
360
+ env: Env | undefined,
361
+ mode: Mode,
362
+ ) =>
363
+ expression.bounds.reduce<{ types: (Type | undefined)[]; last: Type | undefined }>(
364
+ (state, bound, index) => {
365
+ const domain = domains[index];
366
+ const next = (type: Type | undefined) => ({ types: [...state.types, type], last: type });
367
+ if (bound.domain.kind === "Domain" && domain !== undefined)
368
+ return next(getElementType(domain));
369
+ if (bound.domain.kind === "Ditto" && state.last !== undefined) return next(state.last);
370
+ const rest = expression.bounds.slice(index + 1);
371
+ const scope = rest.length === 0 ? expression.body : { ...expression, bounds: rest };
372
+ const names = expression.bounds.slice(0, index).map((innerBound) => innerBound.name);
373
+ const outer = bindVariables(names, env, mode, state.types);
374
+ return next(
375
+ searchDeclarationType(
376
+ encoder,
377
+ scope,
378
+ expression.quantifier === "Forall",
379
+ outer.env,
380
+ outer.mode,
381
+ ),
382
+ );
383
+ },
384
+ { types: [], last: undefined },
385
+ ).types;
386
+
387
+ const encodeQuantifier = (
388
+ encoder: Encoder,
389
+ expression: Extract<Expr, { kind: "Quant" }>,
390
+ env: Env | undefined,
391
+ mode: Mode,
392
+ ) => {
393
+ const domains = encodeDomains(encoder, expression.bounds, env, mode);
394
+ const types = encoder.encoding.isTyped
395
+ ? getBoundTypes(encoder, expression, domains, env, mode)
396
+ : [];
397
+ const bound = bindVariables(
398
+ expression.bounds.map((innerBound) => innerBound.name),
399
+ env,
400
+ mode,
401
+ types,
402
+ );
403
+ const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
404
+ const guards = bound.variables.flatMap((variable, index) => {
405
+ const domain = domains[index];
406
+ if (domain === undefined) return [];
407
+ return [`(${MEM} ${toIdv(getTyped(variable, types[index]))} ${toIdv(domain)})`];
408
+ });
409
+ return expression.quantifier === "Forall"
410
+ ? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
411
+ : `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
412
+ };
413
+
414
+ const getSorts = (count: number, free: string[]) => [
415
+ ...Array.from({ length: count }, () => "Idv"),
416
+ ...free.map((variable) => getVariableSort(variable) ?? "Idv"),
417
+ ];
418
+
419
+ const encodeSetSt = (
420
+ encoder: Encoder,
421
+ expression: Extract<Expr, { kind: "SetSt" }>,
422
+ env: Env | undefined,
423
+ mode: Mode,
424
+ ) => {
425
+ const domain = encode(encoder, expression.domain, env, clearPolarity(mode));
426
+ const bound = bindVariables([expression.name], env, clearPolarity(mode));
427
+ const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
428
+ const free = getFree(body, mode.depth);
429
+ const symbol = encoder.flattener.flatten(
430
+ "SetSt",
431
+ body,
432
+ mode,
433
+ (name) => getSetStAxioms(name, free, body, bound.variables[0]),
434
+ getSorts(1, free),
435
+ );
436
+ return wrapIdv(
437
+ call(symbol, [toIdv(domain), ...free]),
438
+ getSetResult(encoder, [domain], (elements) => getSetType(elements[0])),
439
+ );
440
+ };
441
+
442
+ // At type level 2 tlapm also gives a set of values the types Standardize rejects, so it encodes
443
+ // none.
444
+ const encodeSetOf = (
445
+ encoder: Encoder,
446
+ expression: Extract<Expr, { kind: "SetOf" }>,
447
+ env: Env | undefined,
448
+ mode: Mode,
449
+ ) => {
450
+ const domains = getDomains(encoder, expression.bounds, env, mode, "a set of values");
451
+ const bound = bindVariables(
452
+ expression.bounds.map((innerBound) => innerBound.name),
453
+ env,
454
+ clearPolarity(mode),
455
+ );
456
+ const element = encode(encoder, expression.element, bound.env, clearPolarity(bound.mode));
457
+ const text = toIdv(element);
458
+ const free = getFree(text, mode.depth);
459
+ const count = domains.length;
460
+ const symbol = encoder.flattener.flatten(
461
+ `SetOf_${count}`,
462
+ text,
463
+ mode,
464
+ (name) => getSetOfAxioms(name, free, text, bound.variables),
465
+ getSorts(count, free),
466
+ );
467
+ return wrapIdv(
468
+ call(symbol, [...domains.map(toIdv), ...free]),
469
+ getSetResult(encoder, domains, () => getSetType(getType(element))),
470
+ );
471
+ };
472
+
473
+ // tlapm binds the components of a function of several arguments in a LET. It builds every
474
+ // component from Ix 1, which inside the LET is the previous component, doesn't shift the body past
475
+ // the tuple, and indexes the tuple with untyped numbers that no axiom relates to the tuple's, so
476
+ // this binds each component to its typed index.
477
+ const encodeFunction = (
478
+ encoder: Encoder,
479
+ expression: Extract<Expr, { kind: "Fcn" }>,
480
+ env: Env | undefined,
481
+ mode: Mode,
482
+ ) => {
483
+ const terms = getDomains(encoder, expression.bounds, env, mode, "a function");
484
+ const domains = terms.map(toIdv);
485
+ const domain =
486
+ domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
487
+ const variable = getVariable(domains.length === 1 ? expression.bounds[0].name : "x", mode.depth);
488
+ const inner = { ...clearPolarity(mode), depth: mode.depth + 1 };
489
+ const components = bindVariables(
490
+ domains.length === 1 ? [] : expression.bounds.map((bound) => bound.name),
491
+ env,
492
+ inner,
493
+ );
494
+ const term = encode(
495
+ encoder,
496
+ expression.body,
497
+ domains.length === 1 ? push(env, { kind: "constant", symbol: variable }) : components.env,
498
+ clearPolarity(components.mode),
499
+ );
500
+ const body = toIdv(term);
501
+ const definitions = components.variables.map(
502
+ (component, index) =>
503
+ `(${component} (${FUN_APP} ${variable} ${getNumeral(index + 1, encoder.encoding.isArithmetic)}))`,
504
+ );
505
+ // Smtlib prints the definitions of a LET last first, and N_axiomatize visits them in order.
506
+ const value =
507
+ domains.length === 1 ? body : `(let (${definitions.toReversed().join(" ")}) ${body})`;
508
+ const free = getFree(value, mode.depth);
509
+ const symbol = encoder.flattener.flatten(
510
+ "FunFcn",
511
+ domains.length === 1 ? body : `(let (${definitions.join(" ")}) ${body})`,
512
+ mode,
513
+ (name, axioms) => getFunctionAxioms(name, free, value, variable, axioms),
514
+ getSorts(1, free),
515
+ );
516
+ return wrapIdv(
517
+ call(symbol, [domain, ...free]),
518
+ getSetResult(encoder, terms, (elements) => ({
519
+ kind: "Fun",
520
+ domain: elements.length === 1 ? elements[0] : { kind: "Product", items: elements },
521
+ range: getType(term),
522
+ })),
523
+ );
524
+ };
525
+
526
+ // At type level 2 tlapm sorts the variable of a CHOOSE over a set of type Set(Int) as an Int in
527
+ // its body but an Idv in ChooseDef, which Z3 rejects, so it stays an Idv.
528
+ const encodeChoose = (
529
+ encoder: Encoder,
530
+ expression: Extract<Expr, { kind: "Choose" }>,
531
+ env: Env | undefined,
532
+ mode: Mode,
533
+ ) => {
534
+ const bound = bindVariables([expression.name], env, clearPolarity(mode));
535
+ const variable = bound.variables[0];
536
+ const domain =
537
+ expression.domain && `(${MEM} ${variable} ${encodeIdv(encoder, expression.domain, env, mode)})`;
538
+ const predicate = encodeBool(encoder, expression.body, bound.env, bound.mode);
539
+ const body = domain === undefined ? predicate : conjoin([domain, predicate]);
540
+ const free = getFree(body, mode.depth);
541
+ const symbol = encoder.flattener.flatten(
542
+ "Choose",
543
+ body,
544
+ mode,
545
+ (name) => getChooseAxioms(name, free, body, variable),
546
+ getSorts(0, free),
547
+ );
548
+ return wrapIdv(call(symbol, free));
549
+ };
550
+
551
+ // Type.Synthesize compares values of the same type in their own sort only above type level 1,
552
+ // and Standardize triggers set extensionality on any equality of two sets of one type.
553
+ const encodeEquality = (
554
+ encoder: Encoder,
555
+ args: Expr[],
556
+ env: Env | undefined,
557
+ mode: Mode,
558
+ isNegated: boolean,
559
+ ) => {
560
+ const left = encode(encoder, args[0], env, clearPolarity(mode));
561
+ const right = encode(encoder, args[1], env, clearPolarity(mode));
562
+ const type = getType(left);
563
+ const polarity = encoder.encoding.isSetExtensional ? mode.polarity : undefined;
564
+ if (!encoder.encoding.isTyped || !isSameType(type, getType(right)))
565
+ return getEquality(toIdv(left), toIdv(right), polarity, isNegated);
566
+ if (type.kind === "Int" || type.kind === "Bool") {
567
+ const operands = [left, right].map((term) => term.integer ?? term.text).join(" ");
568
+ return isNegated ? `(distinct ${operands})` : `(= ${operands})`;
569
+ }
570
+ if (type.kind !== "Set") return getEquality(left.text, right.text, polarity, isNegated);
571
+ const name = `TrigEq_${getTypeName(type)}`;
572
+ encoder.setTypes.set(name, type);
573
+ return getEquality(left.text, right.text, polarity, isNegated, tla(name));
574
+ };
575
+
576
+ const getSelectionTest = (encoder: Encoder, test: Expr, env: Env | undefined, mode: Mode) => {
577
+ const lambda = test.kind === "Lambda" && test.params.length === 1 ? test : undefined;
578
+ const bound = bindVariables([lambda?.params[0].name ?? "x1"], env, clearPolarity(mode));
579
+ const body = encodeBool(
580
+ encoder,
581
+ lambda?.body ?? {
582
+ kind: "Apply",
583
+ operator: shiftExpr(1, test),
584
+ args: [{ kind: "Ix", index: 1 }],
585
+ },
586
+ bound.env,
587
+ bound.mode,
588
+ );
589
+ return { body, variable: bound.variables[0] };
590
+ };
591
+
592
+ const encodeBuiltin = (
593
+ encoder: Encoder,
594
+ builtin: Builtin,
595
+ args: Expr[],
596
+ env: Env | undefined,
597
+ mode: Mode,
598
+ ): Term => {
599
+ const getTerms = () => args.map((arg) => encode(encoder, arg, env, clearPolarity(mode)));
600
+ const encodeArgs = () => getTerms().map(toIdv);
601
+ switch (builtin) {
602
+ case "Conj":
603
+ return wrapBool(conjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
604
+ case "Disj":
605
+ return wrapBool(disjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
606
+ case "Implies":
607
+ return wrapBool(
608
+ `(=> ${encodeBool(encoder, args[0], env, invert(mode))} ${encodeBool(encoder, args[1], env, mode)})`,
609
+ );
610
+ case "Equiv":
611
+ return wrapBool(
612
+ `(= ${args.map((arg) => encodeBool(encoder, arg, env, clearPolarity(mode))).join(" ")})`,
613
+ );
614
+ case "Neg":
615
+ return wrapBool(`(not ${encodeBool(encoder, args[0], env, invert(mode))})`);
616
+ case "Eq":
617
+ return wrapBool(encodeEquality(encoder, args, env, mode, false));
618
+ case "Neq":
619
+ return wrapBool(encodeEquality(encoder, args, env, mode, true));
620
+ case "Mem":
621
+ return wrapBool(call(MEM, encodeArgs()));
622
+ case "Notmem":
623
+ return wrapBool(`(not ${call(MEM, encodeArgs())})`);
624
+ case "Subseteq":
625
+ return wrapBool(call(SUBSET_EQ, encodeArgs()));
626
+ case "Lteq":
627
+ case "Gteq":
628
+ case "Lt":
629
+ case "Gt": {
630
+ const terms = getTerms();
631
+ const integers = terms.flatMap((term) => (term.integer === undefined ? [] : [term.integer]));
632
+ if (encoder.encoding.isTyped && integers.length === 2)
633
+ return wrapBool(call(tla(`TInt${builtin}`), integers));
634
+ const order = (operands: string[]) =>
635
+ builtin === "Lteq" || builtin === "Lt" ? operands : operands.toReversed();
636
+ const operands = order(terms.map(toIdv));
637
+ if (builtin === "Lteq" || builtin === "Gteq") return wrapBool(call(INT_LTEQ, operands));
638
+ // Rewrite copies the operands before Flatten, which flattens each copy again.
639
+ return wrapBool(
640
+ `(and ${call(INT_LTEQ, operands)} (distinct ${order(encodeArgs()).join(" ")}))`,
641
+ );
642
+ }
643
+ case "SelectSeq": {
644
+ const test = getSelectionTest(encoder, args[1], env, mode);
645
+ const free = getFree(test.body, mode.depth);
646
+ const symbol = encoder.flattener.flatten(
647
+ "SelectSeq",
648
+ test.body,
649
+ mode,
650
+ (name) =>
651
+ getSelectSeqAxioms(name, free, test.body, test.variable, encoder.encoding.isArithmetic),
652
+ getSorts(1, free),
653
+ );
654
+ return wrapIdv(call(symbol, [encodeIdv(encoder, args[0], env, mode), ...free]));
655
+ }
656
+ case "Unprimable": {
657
+ const term = encode(encoder, args[0], env, clearPolarity(mode));
658
+ return { ...term, text: `(${UNPRIMABLE} ${term.text})` };
659
+ }
660
+ default: {
661
+ const symbol = BUILTIN_SYMBOLS[builtin];
662
+ if (symbol === undefined)
663
+ throw new TlaProverError(
664
+ UNSUPPORTED_OPERANDS.has(builtin)
665
+ ? `Type.Synthesize: Unsupported builtin ${builtin.startsWith("Box") ? "Box" : builtin}`
666
+ : "Type.Synthesize: Unexpected left operand",
379
667
  );
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
- }
668
+ const terms = getTerms();
669
+ if (!encoder.encoding.isTyped) return wrapIdv(call(symbol, terms.map(toIdv)));
670
+ const integers = terms.flatMap((term) => (term.integer === undefined ? [] : [term.integer]));
671
+ if (ARITHMETIC.has(builtin) && integers.length === terms.length)
672
+ return wrapInteger(call(tla(`TInt${builtin}`), integers));
673
+ return wrapIdv(call(symbol, terms.map(toIdv)), getBuiltinType(builtin, terms.map(getType)));
391
674
  }
392
- };
675
+ }
676
+ };
393
677
 
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")
678
+ const encodeReference = (
679
+ encoder: Encoder,
680
+ binding: Binding,
681
+ args: Expr[],
682
+ env: Env | undefined,
683
+ mode: Mode,
684
+ ): Term => {
685
+ switch (binding.kind) {
686
+ case "constant":
687
+ case "variable":
688
+ if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
689
+ return getTyped(binding.symbol, binding.type);
690
+ case "operator":
691
+ if (args.length === 0 && binding.arity > 0)
692
+ throw new TlaProverError("Type.Synthesize: Impossible operator conversion");
693
+ if (args.length !== binding.arity)
694
+ throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
695
+ return wrapIdv(
696
+ call(
697
+ binding.symbol,
698
+ args.map((arg) => encodeIdv(encoder, arg, env, mode)),
699
+ ),
700
+ );
701
+ case "secondOrder": {
702
+ if (args.length !== binding.shapes.length)
703
+ throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
704
+ const operands = args.map((arg, index) => {
705
+ if (binding.shapes[index] === 0)
706
+ return { isFirstOrder: true, text: encodeIdv(encoder, arg, env, mode) };
707
+ if (arg.kind === "Ix") {
708
+ const argument = getBinding(env, arg.index);
709
+ if (argument.kind !== "operator")
431
710
  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,
711
+ return { isFirstOrder: false, text: argument.symbol };
712
+ }
713
+ if (arg.kind !== "Lambda")
714
+ throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
715
+ const bound = bindVariables(
716
+ arg.params.map((param) => param.name),
717
+ env,
718
+ clearPolarity(mode),
453
719
  );
454
- return idv(call(symbol, [...firstOrder, ...free]));
455
- }
456
- case "unsupported":
457
- throw new TlaUnsupportedError(binding.reason);
720
+ return { isFirstOrder: false, text: encodeIdv(encoder, arg.body, bound.env, bound.mode) };
721
+ });
722
+ const firstOrder = operands.flatMap((operand) =>
723
+ operand.isFirstOrder ? [operand.text] : [],
724
+ );
725
+ const higherOrder = operands.flatMap((operand) =>
726
+ operand.isFirstOrder ? [] : [operand.text],
727
+ );
728
+ const free = getFree(higherOrder.join(" "), mode.depth);
729
+ const symbol = encoder.flattener.flatten(
730
+ "",
731
+ higherOrder.join(" "),
732
+ mode,
733
+ () => [],
734
+ getSorts(firstOrder.length, free),
735
+ binding.name,
736
+ );
737
+ return wrapIdv(call(symbol, [...firstOrder, ...free]));
458
738
  }
459
- };
739
+ case "unsupported":
740
+ throw new TlaUnsupportedError(binding.reason);
741
+ }
742
+ };
460
743
 
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
- };
744
+ const getPrimed = (env: Env | undefined, name: string): Term => {
745
+ if (!env) throw new TlaUnsupportedError(`a primed declaration that isn't a variable`);
746
+ const binding = env.binding;
747
+ return binding.kind === "variable" && binding.name === name
748
+ ? getTyped(binding.primed, binding.primedType)
749
+ : getPrimed(env.rest, name);
750
+ };
470
751
 
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
- };
752
+ const encodeOpaque = (
753
+ encoder: Encoder,
754
+ name: string,
755
+ args: Expr[],
756
+ env: Env | undefined,
757
+ mode: Mode,
758
+ ): Term => {
759
+ // Rewrite.simplify_sets writes IsAFcn for the functions in a set of functions.
760
+ if (name === "IsAFcn" && args.length === 1)
761
+ return wrapBool(`(${FUN_ISAFCN} ${encodeIdv(encoder, args[0], env, mode)})`);
762
+ if (args.length === 0 && name.endsWith("#prime"))
763
+ return getPrimed(env, name.slice(0, -"#prime".length));
764
+ const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
765
+ encoder.anonymous.set(anonymousName, args.length);
766
+ return wrapIdv(
767
+ call(
768
+ tla(anonymousName),
769
+ args.map((arg) => encodeIdv(encoder, arg, env, mode)),
770
+ ),
771
+ );
772
+ };
485
773
 
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
- );
774
+ const encodeExcept = (
775
+ encoder: Encoder,
776
+ expression: Extract<Expr, { kind: "Except" }>,
777
+ env: Env | undefined,
778
+ mode: Mode,
779
+ ) =>
780
+ expression.specs.reduce(
781
+ (base, spec) => {
782
+ const update = (value: string, trail: typeof spec.trail): string => {
783
+ if (trail.length === 0) return encodeIdv(encoder, spec.value, env, { ...mode, at: value });
784
+ const point = trail[0];
785
+ const encodeKey = () =>
786
+ point.kind === "Dot"
787
+ ? tla(`StrLit_${point.field}`)
788
+ : encodeIdv(encoder, point.expression, env, mode);
789
+ const key = encodeKey();
790
+ // Elab.desugar repeats the key in the value it updates, and Flatten counts both.
791
+ const inner = update(
792
+ `(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
793
+ trail.slice(1),
794
+ );
795
+ return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
796
+ };
797
+ return update(base, spec.trail);
798
+ },
799
+ encodeIdv(encoder, expression.function, env, mode),
800
+ );
513
801
 
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
- };
802
+ const getCaseError = (encoder: Encoder) => {
803
+ encoder.session.caseErrors++;
804
+ const name = `Anon_incomplete_case_error_${encoder.session.caseErrors}`;
805
+ encoder.anonymous.set(name, 0);
806
+ return tla(name);
807
+ };
521
808
 
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 ?? "",
540
- );
541
- return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
542
- }
543
- const convert = (term: Term) => (isBool ? term.text : toIdv(term));
544
- const text = expression.arms.reduceRight(
809
+ const encodeCase = (
810
+ encoder: Encoder,
811
+ expression: Extract<Expr, { kind: "Case" }>,
812
+ env: Env | undefined,
813
+ mode: Mode,
814
+ ): Term => {
815
+ const bodies = expression.arms.map((arm) => encode(encoder, arm.body, env, mode));
816
+ const other: Term = expression.other
817
+ ? encode(encoder, expression.other, env, mode)
818
+ : wrapIdv(getCaseError(encoder));
819
+ const type = getType(other);
820
+ const isUniform = bodies.every((body) => isSameType(getType(body), type));
821
+ const isBool = isUniform && type.kind === "Bool";
822
+ if (isUniform && type.kind === "Int") {
823
+ const integer = expression.arms.reduceRight(
545
824
  (rest, arm, index) =>
546
- `(ite ${encodeBool(arm.condition, env, mode)} ${convert(bodies[index])} ${rest})`,
547
- convert(other),
825
+ `(ite ${encodeBool(encoder, arm.condition, env, clearPolarity(mode))} ${bodies[index].integer} ${rest})`,
826
+ other.integer ?? "",
548
827
  );
549
- return { isBool, text };
828
+ return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
829
+ }
830
+ const convert = (term: Term) => (isBool ? term.text : toIdv(term));
831
+ const text = expression.arms.reduceRight(
832
+ (rest, arm, index) =>
833
+ `(ite ${encodeBool(encoder, arm.condition, env, mode)} ${convert(bodies[index])} ${rest})`,
834
+ convert(other),
835
+ );
836
+ return { isBool, text, type: isUniform ? other.type : undefined };
837
+ };
838
+
839
+ // Type.Synthesize types a NEW constant by its visible domain, or else by a hypothesis in the rest
840
+ // of the sequent. The guard is its membership in the domain the encoding asserts.
841
+ export const declareConstant = (
842
+ encoder: Encoder,
843
+ hyp: Extract<Hyp, { kind: "Fresh" }>,
844
+ guarded: Expr | undefined,
845
+ rest: Sequent,
846
+ env: Env | undefined,
847
+ mode: Mode,
848
+ ) => {
849
+ const domain = guarded && encode(encoder, guarded, env, clearPolarity(mode));
850
+ const type =
851
+ domain !== undefined && hyp.domainVisibility === "Visible"
852
+ ? getElementType(domain)
853
+ : searchDeclarationType(encoder, { kind: "Sequent", sequent: rest }, true, env, mode);
854
+ return {
855
+ type,
856
+ getGuard: (symbol: string) =>
857
+ domain && `(${MEM} ${toIdv(getTyped(symbol, type))} ${toIdv(domain)})`,
550
858
  };
859
+ };
551
860
 
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;
861
+ const encodeSequent = (
862
+ encoder: Encoder,
863
+ sequent: Sequent,
864
+ env: Env | undefined,
865
+ mode: Mode,
866
+ ): string => {
867
+ const steps = sequent.context.reduce<NestedContext>(
868
+ (state, hyp, index) => {
869
+ switch (hyp.kind) {
870
+ case "Fresh": {
871
+ if (hyp.shape > 0) {
872
+ if (!state.mode.isOmitted) throw new TlaUnsupportedError("a second-order ASSUME");
873
+ const variable = getVariable(hyp.name, state.mode.depth);
586
874
  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,
875
+ env: push(state.env, { kind: "operator", symbol: variable, arity: hyp.shape }),
876
+ mode: { ...state.mode, depth: state.mode.depth + 1 },
877
+ wrappers: [...state.wrappers, (body) => `(forall ((${variable} Idv)) ${body})`],
592
878
  };
593
879
  }
594
- default:
595
- throw new TlaUnsupportedError(`a ${hyp.kind} in a nested ASSUME`);
880
+ if (hyp.level !== "Constant")
881
+ throw new TlaUnsupportedError("a NEW declaration that isn't constant");
882
+ const rest = { context: sequent.context.slice(index + 1), active: sequent.active };
883
+ const declared = declareConstant(encoder, hyp, hyp.domain, rest, state.env, state.mode);
884
+ const bound = bindVariables([hyp.name], state.env, state.mode, [declared.type]);
885
+ const variable = bound.variables[0];
886
+ const guard = declared.getGuard(variable);
887
+ return {
888
+ env: bound.env,
889
+ mode: bound.mode,
890
+ wrappers: [
891
+ ...state.wrappers,
892
+ (body) =>
893
+ `(forall (${getBinders([variable])}) ${guard ? `(=> ${guard} ${body})` : body})`,
894
+ ],
895
+ };
596
896
  }
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}`);
626
- }
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 };
897
+ case "Fact": {
898
+ const fact =
899
+ hyp.visibility === "Visible"
900
+ ? encodeBool(encoder, hyp.expression, state.env, invert(state.mode))
901
+ : undefined;
902
+ return {
903
+ env: push(state.env, { kind: "unsupported", reason: "a reference to a fact" }),
904
+ mode: state.mode,
905
+ wrappers: fact ? [...state.wrappers, (body) => `(=> ${fact} ${body})`] : state.wrappers,
906
+ };
651
907
  }
652
- return consequent.isBool && alternative.isBool
653
- ? bool(`(ite ${condition} ${consequent.text} ${alternative.text})`)
654
- : idv(`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`);
908
+ default:
909
+ throw new TlaUnsupportedError(`a ${hyp.kind} in a nested ASSUME`);
655
910
  }
656
- case "List": {
657
- const items = expression.items.map((item) => encodeBool(item, env, mode));
658
- return bool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
659
- }
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})`);
911
+ },
912
+ { env, mode, wrappers: [] },
913
+ );
914
+ return steps.wrappers.reduceRight(
915
+ (body, wrap) => wrap(body),
916
+ encodeBool(encoder, sequent.active, steps.env, steps.mode),
917
+ );
918
+ };
919
+
920
+ const encode = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode): Term => {
921
+ switch (expression.kind) {
922
+ case "Ix":
923
+ return encodeReference(encoder, getBinding(env, expression.index), [], env, mode);
924
+ case "Internal":
925
+ switch (expression.builtin) {
926
+ case "TRUE":
927
+ return wrapBool("true");
928
+ case "FALSE":
929
+ return wrapBool("false");
930
+ case "BOOLEAN":
931
+ return wrapIdv(BOOL_SET, getTypedOnly(encoder, getSetType(BOOL)));
932
+ case "STRING":
933
+ return wrapIdv(STR_SET, getTypedOnly(encoder, getSetType(STRING)));
934
+ case "Nat":
935
+ return wrapIdv(NAT_SET, getTypedOnly(encoder, getSetType(INT)));
936
+ case "Int":
937
+ return wrapIdv(INT_SET, getTypedOnly(encoder, getSetType(INT)));
938
+ case "Real":
939
+ case "Infinity":
940
+ throw new TlaProverError(
941
+ `Encode.Standardize: Unexpected builtin '${expression.builtin}'`,
942
+ );
943
+ default:
944
+ throw new TlaProverError("Type.Synthesize: Unexpected builtin");
699
945
  }
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
- ),
946
+ case "Apply": {
947
+ const operator = expression.operator;
948
+ if (operator.kind === "Internal")
949
+ return encodeBuiltin(encoder, operator.builtin, expression.args, env, mode);
950
+ if (operator.kind === "Ix")
951
+ return encodeReference(
952
+ encoder,
953
+ getBinding(env, operator.index),
954
+ expression.args,
955
+ env,
956
+ mode,
718
957
  );
958
+ if (operator.kind === "Opaque")
959
+ return encodeOpaque(encoder, operator.name, expression.args, env, mode);
960
+ if (operator.kind === "Lambda")
961
+ return encode(encoder, normalizeApply(operator, expression.args), env, mode);
962
+ throw new TlaUnsupportedError(`an application of ${operator.kind}`);
963
+ }
964
+ case "Sequent":
965
+ return wrapBool(encodeSequent(encoder, expression.sequent, env, mode));
966
+ case "With":
967
+ case "Parens":
968
+ return encode(encoder, expression.expression, env, mode);
969
+ case "If": {
970
+ const condition = encodeBool(encoder, expression.condition, env, mode);
971
+ const consequent = encode(encoder, expression.consequent, env, mode);
972
+ const alternative = encode(encoder, expression.alternative, env, mode);
973
+ if (consequent.integer !== undefined && alternative.integer !== undefined) {
974
+ const integer = `(ite ${resolveTriggers(condition, true)} ${consequent.integer} ${alternative.integer})`;
975
+ return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
719
976
  }
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}`);
977
+ if (consequent.isBool && alternative.isBool)
978
+ return wrapBool(`(ite ${condition} ${consequent.text} ${alternative.text})`);
979
+ return wrapIdv(
980
+ `(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`,
981
+ isSameType(getType(consequent), getType(alternative)) ? consequent.type : undefined,
982
+ );
746
983
  }
747
- };
984
+ case "List": {
985
+ const items = expression.items.map((item) => encodeBool(encoder, item, env, mode));
986
+ return wrapBool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
987
+ }
988
+ case "Opaque":
989
+ return encodeOpaque(encoder, expression.name, [], env, mode);
990
+ case "Quant":
991
+ return wrapBool(encodeQuantifier(encoder, expression, env, mode));
992
+ case "Choose":
993
+ return encodeChoose(encoder, expression, env, mode);
994
+ case "SetSt":
995
+ return encodeSetSt(encoder, expression, env, mode);
996
+ case "SetOf":
997
+ return encodeSetOf(encoder, expression, env, mode);
998
+ case "SetEnum": {
999
+ const elements = expression.elements.map((element) =>
1000
+ encode(encoder, element, env, clearPolarity(mode)),
1001
+ );
1002
+ const types = elements.map(getType);
1003
+ return wrapIdv(
1004
+ call(tla(`SetEnum_${elements.length}`), elements.map(toIdv)),
1005
+ getTypedOnly(
1006
+ encoder,
1007
+ types.every((type) => isSameType(type, types[0] ?? IDV))
1008
+ ? getSetType(types[0] ?? IDV)
1009
+ : undefined,
1010
+ ),
1011
+ );
1012
+ }
1013
+ case "Product": {
1014
+ const factors = expression.factors.map((factor) =>
1015
+ encode(encoder, factor, env, clearPolarity(mode)),
1016
+ );
1017
+ return wrapIdv(
1018
+ call(tla(`Product_${factors.length}`), factors.map(toIdv)),
1019
+ getSetResult(encoder, factors, (items) => getSetType({ kind: "Product", items })),
1020
+ );
1021
+ }
1022
+ case "Tuple": {
1023
+ const elements = expression.elements.map((element) =>
1024
+ encode(encoder, element, env, clearPolarity(mode)),
1025
+ );
1026
+ return wrapIdv(
1027
+ call(tla(`Tuple_${elements.length}`), elements.map(toIdv)),
1028
+ getTypedOnly(encoder, { kind: "Product", items: elements.map(getType) }),
1029
+ );
1030
+ }
1031
+ case "Fcn":
1032
+ return encodeFunction(encoder, expression, env, mode);
1033
+ case "FcnApp": {
1034
+ const encodedFunction = encode(encoder, expression.function, env, clearPolarity(mode));
1035
+ const args = expression.args.map((arg) => encodeIdv(encoder, arg, env, mode));
1036
+ const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
1037
+ const text = `(${FUN_APP} ${toIdv(encodedFunction)} ${argument})`;
1038
+ const component = getTypedOnly(
1039
+ encoder,
1040
+ getComponentType(getType(encodedFunction), expression.args),
1041
+ );
1042
+ return component === undefined ? wrapIdv(text) : project(text, component);
1043
+ }
1044
+ case "Arrow": {
1045
+ const sets = [expression.domain, expression.range].map((set) =>
1046
+ encode(encoder, set, env, clearPolarity(mode)),
1047
+ );
1048
+ return wrapIdv(
1049
+ call(FUN_SET, sets.map(toIdv)),
1050
+ getSetResult(encoder, sets, (elements) =>
1051
+ getSetType({ kind: "Fun", domain: elements[0], range: elements[1] }),
1052
+ ),
1053
+ );
1054
+ }
1055
+ case "Record":
1056
+ case "Rect": {
1057
+ const names = expression.fields.map((field) => field.name);
1058
+ const suffix = names.join("_");
1059
+ encoder.recordFields.set(`Record_${suffix}`, names);
1060
+ encoder.recordFields.set(`RecordSet_${suffix}`, names);
1061
+ const values = expression.fields.map((field) =>
1062
+ encode(encoder, field.value, env, clearPolarity(mode)),
1063
+ );
1064
+ // Type.Synthesize types a set of records only at type level 3.
1065
+ const type: Type = {
1066
+ kind: "Record",
1067
+ fields: names.map((name, index) => ({ name, type: getType(values[index]) })),
1068
+ };
1069
+ return wrapIdv(
1070
+ call(
1071
+ tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
1072
+ values.map(toIdv),
1073
+ ),
1074
+ expression.kind === "Record" ? getTypedOnly(encoder, type) : undefined,
1075
+ );
1076
+ }
1077
+ case "Except":
1078
+ return wrapIdv(encodeExcept(encoder, expression, env, mode));
1079
+ case "Dot": {
1080
+ const record = encode(encoder, expression.expression, env, clearPolarity(mode));
1081
+ const text = `(${FUN_APP} ${toIdv(record)} ${tla(`StrLit_${expression.field}`)})`;
1082
+ const component = getTypedOnly(encoder, getFieldType(getType(record), expression.field));
1083
+ return component === undefined ? wrapIdv(text) : project(text, component);
1084
+ }
1085
+ case "Case":
1086
+ return encodeCase(encoder, expression, env, mode);
1087
+ case "String":
1088
+ return wrapIdv(tla(`StrLit_${expression.value}`), getTypedOnly(encoder, STRING));
1089
+ case "Num":
1090
+ if (expression.fraction !== "") throw new TlaUnsupportedError("a real number");
1091
+ // Deviation from tlapm: its int_of_string fails the obligation for a literal above 2^62 - 1.
1092
+ // Type.Synthesize gives a number no type when arithmetic is off.
1093
+ if (!encoder.encoding.isArithmetic)
1094
+ return wrapIdv(tla(`IntLit_${BigInt(expression.integer)}`));
1095
+ return {
1096
+ isBool: false,
1097
+ text: `(${CAST_INT} ${BigInt(expression.integer)})`,
1098
+ integer: String(BigInt(expression.integer)),
1099
+ };
1100
+ case "At":
1101
+ if (mode.at === undefined) throw new TlaUnsupportedError("@ outside EXCEPT");
1102
+ return wrapIdv(mode.at);
1103
+ case "Tquant":
1104
+ case "Tsub":
1105
+ case "Fair":
1106
+ throw new TlaProverError("Backend.Smtlib: Unsupported expression");
1107
+ case "Lambda":
1108
+ case "Bang":
1109
+ throw new TlaProverError(`Type.Synthesize: Unexpected ${expression.kind} constructor`);
1110
+ default:
1111
+ throw new TlaUnsupportedError(`the expression ${expression.kind}`);
1112
+ }
1113
+ };
748
1114
 
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
- ];
1115
+ export const getEntries = (encoder: Encoder, line: string): Entry[] => [
1116
+ ...encoder.flattener.takeIntroduced(),
1117
+ removeUnprimable(resolveTriggers(line, false)),
1118
+ ];
754
1119
 
755
- return {
756
- encodeIdv,
757
- encodeBool,
758
- push,
759
- getEntries,
760
- getUniqueName,
761
- flattened: flattener.flattened,
762
- anonymous,
763
- recordFields,
764
- declared,
765
- };
766
- };
1120
+ export const createEncoder = (session: EncodingSession, encoding: SmtEncoding): Encoder => ({
1121
+ session,
1122
+ encoding,
1123
+ flattener: createFlattener(),
1124
+ anonymous: new Map(),
1125
+ recordFields: new Map(),
1126
+ setTypes: new Map(),
1127
+ context: createContext(),
1128
+ declared: new Map(),
1129
+ });