tla-ts 0.0.10-dev.28c823e4b → 0.0.10-dev.4a2a53c48

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