tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.68b2c4968

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 (542) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +3 -3
  3. package/dist/compile.js +1 -1
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +45 -41
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +4 -1
  8. package/dist/index.d.ts +4 -1
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -1
  11. package/dist/parallel-worker.js +1 -1
  12. package/dist/prove-worker.cjs +1 -1
  13. package/dist/prove-worker.js +1 -1
  14. package/dist/prove.cjs +2682 -426
  15. package/dist/prove.js +2679 -423
  16. package/dist/run.cjs +43 -42
  17. package/dist/run.js +44 -43
  18. package/dist/tlapm.cjs +1 -1
  19. package/dist/tlapm.js +1 -1
  20. package/dist/transfer.cjs +44 -41
  21. package/dist/transfer.js +43 -40
  22. package/dist/worker.cjs +7 -7
  23. package/dist/worker.js +7 -7
  24. package/package.json +1 -1
  25. package/src/ast.ts +3 -3
  26. package/src/bags.ts +46 -28
  27. package/src/check-trace.ts +2 -16
  28. package/src/check.ts +349 -91
  29. package/src/cli/runtime-invariants.ts +20 -56
  30. package/src/cli/tlapm.ts +424 -62
  31. package/src/cli/tlc-arguments.ts +2 -2
  32. package/src/cli/tlc-output.ts +4 -5
  33. package/src/cli/tlc-usage.ts +0 -1
  34. package/src/cli/tlc.ts +26 -7
  35. package/src/codegen.ts +6 -2
  36. package/src/dependencies.ts +72 -11
  37. package/src/dfid.ts +9 -2
  38. package/src/environment.ts +27 -5
  39. package/src/errors.ts +38 -3
  40. package/src/evaluate.ts +92 -32
  41. package/src/exit-codes.ts +5 -2
  42. package/src/instances.ts +1 -1
  43. package/src/levels.ts +134 -86
  44. package/src/lexer.ts +5 -3
  45. package/src/liveness-checker.ts +572 -204
  46. package/src/liveness.ts +47 -32
  47. package/src/obligations/action.ts +10 -6
  48. package/src/obligations/anonymize.ts +33 -14
  49. package/src/obligations/enabled-axioms.ts +218 -0
  50. package/src/obligations/equality.ts +1 -3
  51. package/src/obligations/expression.ts +18 -6
  52. package/src/obligations/format.ts +0 -2
  53. package/src/obligations/generate.ts +22 -17
  54. package/src/obligations/index.ts +36 -6
  55. package/src/obligations/levels.ts +24 -11
  56. package/src/obligations/module.ts +1 -3
  57. package/src/obligations/normalize.ts +24 -13
  58. package/src/obligations/operators.ts +0 -2
  59. package/src/obligations/pragma.ts +53 -16
  60. package/src/obligations/printer.ts +43 -13
  61. package/src/obligations/proof.ts +3 -2
  62. package/src/obligations/regroup.ts +0 -2
  63. package/src/obligations/simplify.ts +17 -7
  64. package/src/obligations/source.ts +71 -17
  65. package/src/obligations/subexpression.ts +45 -18
  66. package/src/obligations/substitution.ts +1 -3
  67. package/src/obligations/temporal.ts +0 -2
  68. package/src/obligations/tuples.ts +0 -2
  69. package/src/parallel-worker.ts +8 -2
  70. package/src/parallel.ts +7 -2
  71. package/src/parser.ts +634 -186
  72. package/src/pretty-print.ts +1 -1
  73. package/src/prover/deciders.ts +11 -8
  74. package/src/prover/isabelle/decide.ts +3 -25
  75. package/src/prover/isabelle/encode.ts +71 -41
  76. package/src/prover/isabelle/isar/attrib.ts +250 -0
  77. package/src/prover/isabelle/isar/context.ts +335 -0
  78. package/src/prover/isabelle/isar/induct.ts +382 -0
  79. package/src/prover/isabelle/isar/inner-syntax.ts +149 -3
  80. package/src/prover/isabelle/isar/method.ts +506 -198
  81. package/src/prover/isabelle/isar/proof.ts +570 -14
  82. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  83. package/src/prover/isabelle/isar/theory.ts +479 -69
  84. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  85. package/src/prover/isabelle/isar/type-check.ts +83 -8
  86. package/src/prover/isabelle/provers/blast/blast.ts +0 -2
  87. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  88. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  89. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  90. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  91. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  92. package/src/prover/isabelle/provers/clasimp.ts +1 -3
  93. package/src/prover/isabelle/provers/classical.ts +45 -20
  94. package/src/prover/isabelle/provers/hypsubst.ts +2 -4
  95. package/src/prover/isabelle/pure/bicompose.ts +0 -2
  96. package/src/prover/isabelle/pure/consts.ts +0 -2
  97. package/src/prover/isabelle/pure/conv.ts +0 -2
  98. package/src/prover/isabelle/pure/drule.ts +63 -4
  99. package/src/prover/isabelle/pure/envir.ts +0 -2
  100. package/src/prover/isabelle/pure/goal.ts +1 -3
  101. package/src/prover/isabelle/pure/logic.ts +0 -2
  102. package/src/prover/isabelle/pure/name.ts +0 -2
  103. package/src/prover/isabelle/pure/net.ts +0 -2
  104. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  105. package/src/prover/isabelle/pure/pattern.ts +0 -2
  106. package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
  107. package/src/prover/isabelle/pure/rewriter.ts +1 -8
  108. package/src/prover/isabelle/pure/search.ts +0 -2
  109. package/src/prover/isabelle/pure/seq.ts +0 -2
  110. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  111. package/src/prover/isabelle/pure/table.ts +0 -2
  112. package/src/prover/isabelle/pure/tactic.ts +0 -2
  113. package/src/prover/isabelle/pure/tactical.ts +0 -2
  114. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  115. package/src/prover/isabelle/pure/term.ts +0 -2
  116. package/src/prover/isabelle/pure/thm.ts +0 -2
  117. package/src/prover/isabelle/pure/type.ts +0 -2
  118. package/src/prover/isabelle/pure/unify.ts +0 -2
  119. package/src/prover/isabelle/pure/variable.ts +0 -2
  120. package/src/prover/isabelle/tla/classical-setup.ts +1 -2
  121. package/src/prover/isabelle/tla/context.ts +51 -9
  122. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  123. package/src/prover/isabelle/tla/logic.ts +40 -1
  124. package/src/prover/isabelle/tla/simpdata.ts +0 -2
  125. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  126. package/src/prover/ocaml.ts +4 -1
  127. package/src/prover/prep/action.ts +19 -12
  128. package/src/prover/prep/enabled-axioms.ts +11 -2
  129. package/src/prover/prep/methods.ts +159 -50
  130. package/src/prover/prep/normalize.ts +38 -9
  131. package/src/prover/prove.ts +343 -65
  132. package/src/prover/ptl/decide.ts +95 -50
  133. package/src/prover/ptl/encode.ts +2 -3
  134. package/src/prover/ptl/tableau.ts +28 -2
  135. package/src/prover/smt/arithmetic.ts +310 -0
  136. package/src/prover/smt/axioms.ts +12 -8
  137. package/src/prover/smt/context.ts +42 -6
  138. package/src/prover/smt/data.ts +191 -84
  139. package/src/prover/smt/encode.ts +122 -43
  140. package/src/prover/smt/extensionality.ts +5 -3
  141. package/src/prover/smt/flatten.ts +4 -6
  142. package/src/prover/smt/format.ts +28 -4
  143. package/src/prover/smt/instances.ts +7 -1
  144. package/src/prover/smt/layout.ts +91 -0
  145. package/src/prover/smt/rewrite.ts +483 -116
  146. package/src/prover/smt/simplify.ts +441 -0
  147. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +61 -0
  148. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  149. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  150. package/src/prover/smt/solver/act-cache.ts +0 -1
  151. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  152. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  153. package/src/prover/smt/solver/aig.ts +889 -0
  154. package/src/prover/smt/solver/arith-rewriter.ts +613 -6
  155. package/src/prover/smt/solver/arith-terms.ts +121 -0
  156. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  157. package/src/prover/smt/solver/array-rewriter.ts +309 -0
  158. package/src/prover/smt/solver/asserted-formulas.ts +93 -15
  159. package/src/prover/smt/solver/ast-lt.ts +165 -11
  160. package/src/prover/smt/solver/ast-util.ts +160 -2
  161. package/src/prover/smt/solver/ast.ts +1449 -41
  162. package/src/prover/smt/solver/auf-solver.ts +0 -1
  163. package/src/prover/smt/solver/bit-blast-tactic.ts +582 -0
  164. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  165. package/src/prover/smt/solver/bound-manager.ts +196 -0
  166. package/src/prover/smt/solver/bound-simplifier.ts +600 -0
  167. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  168. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  169. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  170. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  171. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  172. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  173. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  174. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  175. package/src/prover/smt/solver/card2bv.ts +109 -0
  176. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  177. package/src/prover/smt/solver/cg-table.ts +39 -25
  178. package/src/prover/smt/solver/check-logic.ts +330 -0
  179. package/src/prover/smt/solver/clause.ts +0 -1
  180. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +278 -0
  181. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  182. package/src/prover/smt/solver/context.ts +533 -114
  183. package/src/prover/smt/solver/ctx-simplify.ts +21 -12
  184. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  185. package/src/prover/smt/solver/datatype-decl-plugin.ts +572 -0
  186. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  187. package/src/prover/smt/solver/demodulator.ts +786 -0
  188. package/src/prover/smt/solver/dependent-expr-state.ts +81 -0
  189. package/src/prover/smt/solver/der.ts +38 -10
  190. package/src/prover/smt/solver/diff-neq.ts +205 -0
  191. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  192. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  193. package/src/prover/smt/solver/dt2bv-tactic.ts +260 -0
  194. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  195. package/src/prover/smt/solver/e-matching.ts +6 -7
  196. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  197. package/src/prover/smt/solver/elim-uncnstr.ts +542 -0
  198. package/src/prover/smt/solver/enode.ts +100 -3
  199. package/src/prover/smt/solver/eq2bv-tactic.ts +218 -0
  200. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  201. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  202. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  203. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  204. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  205. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  206. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  207. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  208. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  209. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  210. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  211. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  212. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  213. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  214. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  215. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  216. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  217. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  218. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  219. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  220. package/src/prover/smt/solver/expr-ref.ts +0 -1
  221. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  222. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  223. package/src/prover/smt/solver/factor.ts +163 -0
  224. package/src/prover/smt/solver/fd-solver.ts +267 -0
  225. package/src/prover/smt/solver/fingerprints.ts +15 -15
  226. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  227. package/src/prover/smt/solver/flat-literals.ts +0 -1
  228. package/src/prover/smt/solver/fm-tactic.ts +884 -0
  229. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  230. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  231. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  232. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  233. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  234. package/src/prover/smt/solver/goal.ts +177 -15
  235. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  236. package/src/prover/smt/solver/guard-set.ts +219 -0
  237. package/src/prover/smt/solver/hash.ts +0 -1
  238. package/src/prover/smt/solver/hashtable.ts +30 -16
  239. package/src/prover/smt/solver/inf-eps.ts +63 -0
  240. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  241. package/src/prover/smt/solver/internalizer.ts +109 -36
  242. package/src/prover/smt/solver/lackr.ts +381 -0
  243. package/src/prover/smt/solver/lbool.ts +0 -1
  244. package/src/prover/smt/solver/lia2card.ts +268 -0
  245. package/src/prover/smt/solver/lia2pb.ts +154 -0
  246. package/src/prover/smt/solver/literal.ts +0 -1
  247. package/src/prover/smt/solver/logic-tactics.ts +345 -0
  248. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  249. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  250. package/src/prover/smt/solver/lp/containers.ts +7 -2
  251. package/src/prover/smt/solver/lp/core-solver.ts +18 -3
  252. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  253. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  254. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  255. package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
  256. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  257. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  258. package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
  259. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  260. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  261. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  262. package/src/prover/smt/solver/lp/lar-solver.ts +40 -4
  263. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  264. package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
  265. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  266. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  267. package/src/prover/smt/solver/lp/nex.ts +2 -2
  268. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  269. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  270. package/src/prover/smt/solver/lp/nla-core.ts +66 -11
  271. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  272. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  273. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  274. package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
  275. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  276. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  277. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  278. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  279. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  280. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  281. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  282. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  283. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  284. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  285. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  286. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  287. package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
  288. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  289. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  290. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  291. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  292. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  293. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  294. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  295. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  296. package/src/prover/smt/solver/macro-finder.ts +530 -0
  297. package/src/prover/smt/solver/mam-compiler.ts +118 -88
  298. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  299. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  300. package/src/prover/smt/solver/max-cliques.ts +105 -0
  301. package/src/prover/smt/solver/maxcore.ts +309 -0
  302. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  303. package/src/prover/smt/solver/maxlex.ts +115 -0
  304. package/src/prover/smt/solver/maxsmt-base.ts +105 -0
  305. package/src/prover/smt/solver/maxsmt.ts +92 -0
  306. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  307. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  308. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  309. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  310. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  311. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  312. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  313. package/src/prover/smt/solver/model-checker.ts +17 -26
  314. package/src/prover/smt/solver/model-evaluator.ts +188 -12
  315. package/src/prover/smt/solver/model-finder.ts +0 -1
  316. package/src/prover/smt/solver/model-generator.ts +59 -30
  317. package/src/prover/smt/solver/model-macro-solver.ts +38 -27
  318. package/src/prover/smt/solver/model-printer.ts +214 -0
  319. package/src/prover/smt/solver/mpf.ts +709 -0
  320. package/src/prover/smt/solver/mus.ts +50 -0
  321. package/src/prover/smt/solver/muz/dl-context.ts +410 -0
  322. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  323. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  324. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  325. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  326. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  327. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  328. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  329. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  330. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  331. package/src/prover/smt/solver/muz/dl-rule.ts +496 -0
  332. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  333. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  334. package/src/prover/smt/solver/muz/horn-tactic.ts +201 -0
  335. package/src/prover/smt/solver/muz/rule-properties.ts +337 -0
  336. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  337. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  338. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  339. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  340. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  341. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  342. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  343. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  344. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  345. package/src/prover/smt/solver/nlqsat.ts +484 -0
  346. package/src/prover/smt/solver/nlsat/algebraic.ts +305 -88
  347. package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
  348. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  349. package/src/prover/smt/solver/nlsat/explain.ts +424 -211
  350. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  351. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
  352. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  353. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
  354. package/src/prover/smt/solver/nlsat/solver.ts +282 -69
  355. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  356. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  357. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  358. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -7
  359. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
  360. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  361. package/src/prover/smt/solver/nnf.ts +105 -23
  362. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  363. package/src/prover/smt/solver/occf.ts +97 -0
  364. package/src/prover/smt/solver/opt-context.ts +792 -0
  365. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  366. package/src/prover/smt/solver/opt-pareto.ts +282 -0
  367. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  368. package/src/prover/smt/solver/opt-solver.ts +311 -0
  369. package/src/prover/smt/solver/opt-value.ts +55 -0
  370. package/src/prover/smt/solver/optsmt.ts +692 -0
  371. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  372. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  373. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  374. package/src/prover/smt/solver/pb2bv-tactic.ts +540 -0
  375. package/src/prover/smt/solver/poly-rewriter.ts +202 -57
  376. package/src/prover/smt/solver/probes.ts +511 -0
  377. package/src/prover/smt/solver/propagate-values.ts +37 -21
  378. package/src/prover/smt/solver/proto-model.ts +650 -17
  379. package/src/prover/smt/solver/pull-quant.ts +28 -12
  380. package/src/prover/smt/solver/purify-arith.ts +632 -0
  381. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  382. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  383. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  384. package/src/prover/smt/solver/qe-lite.ts +37 -17
  385. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  386. package/src/prover/smt/solver/qe.ts +1499 -0
  387. package/src/prover/smt/solver/qel.ts +25 -0
  388. package/src/prover/smt/solver/qi-queue.ts +0 -1
  389. package/src/prover/smt/solver/qsat.ts +814 -0
  390. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  391. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  392. package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
  393. package/src/prover/smt/solver/quantifier-manager.ts +25 -24
  394. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  395. package/src/prover/smt/solver/random-gen.ts +0 -1
  396. package/src/prover/smt/solver/rational.ts +45 -1
  397. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  398. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  399. package/src/prover/smt/solver/reduce-args.ts +225 -0
  400. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  401. package/src/prover/smt/solver/ref-vector.ts +0 -1
  402. package/src/prover/smt/solver/relevancy.ts +1 -2
  403. package/src/prover/smt/solver/rewriter-tpl.ts +77 -10
  404. package/src/prover/smt/solver/rewriter.ts +475 -36
  405. package/src/prover/smt/solver/rlimit.ts +38 -2
  406. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  407. package/src/prover/smt/solver/sat/big.ts +177 -0
  408. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  409. package/src/prover/smt/solver/sat/clause.ts +203 -0
  410. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  411. package/src/prover/smt/solver/sat/config.ts +122 -0
  412. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  413. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  414. package/src/prover/smt/solver/sat/goal2sat.ts +526 -0
  415. package/src/prover/smt/solver/sat/inc-sat-solver.ts +378 -0
  416. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  417. package/src/prover/smt/solver/sat/pb-constraint.ts +261 -0
  418. package/src/prover/smt/solver/sat/pb-solver.ts +1577 -0
  419. package/src/prover/smt/solver/sat/probing.ts +170 -0
  420. package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
  421. package/src/prover/smt/solver/sat/sat2goal.ts +165 -0
  422. package/src/prover/smt/solver/sat/scc.ts +142 -0
  423. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  424. package/src/prover/smt/solver/sat/solver.ts +2105 -0
  425. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  426. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  427. package/src/prover/smt/solver/search-tree.ts +284 -0
  428. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  429. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  430. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  431. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  432. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  433. package/src/prover/smt/solver/seq-factory.ts +89 -0
  434. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  435. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  436. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  437. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  438. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  439. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  440. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  441. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  442. package/src/prover/smt/solver/seq-subset.ts +165 -0
  443. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  444. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  445. package/src/prover/smt/solver/smt-kernel.ts +90 -0
  446. package/src/prover/smt/solver/smt-logics.ts +66 -0
  447. package/src/prover/smt/solver/smt-setup.ts +544 -0
  448. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  449. package/src/prover/smt/solver/smtlib-parser.ts +3228 -327
  450. package/src/prover/smt/solver/smtlib-script.ts +1843 -0
  451. package/src/prover/smt/solver/solve-eqs.ts +923 -0
  452. package/src/prover/smt/solver/solver.ts +113 -22
  453. package/src/prover/smt/solver/static-features.ts +314 -0
  454. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  455. package/src/prover/smt/solver/tactic.ts +2012 -0
  456. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  457. package/src/prover/smt/solver/theory-array.ts +1240 -0
  458. package/src/prover/smt/solver/theory-bv.ts +1200 -0
  459. package/src/prover/smt/solver/theory-char.ts +355 -0
  460. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  461. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  462. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  463. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  464. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -5
  465. package/src/prover/smt/solver/theory-lra-final-check.ts +56 -71
  466. package/src/prover/smt/solver/theory-lra-internalize.ts +89 -11
  467. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  468. package/src/prover/smt/solver/theory-lra-propagate.ts +24 -28
  469. package/src/prover/smt/solver/theory-lra-state.ts +6 -22
  470. package/src/prover/smt/solver/theory-lra.ts +188 -2
  471. package/src/prover/smt/solver/theory-pb.ts +933 -0
  472. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  473. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  474. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  475. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  476. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  477. package/src/prover/smt/solver/theory-seq.ts +961 -0
  478. package/src/prover/smt/solver/theory.ts +189 -0
  479. package/src/prover/smt/solver/tseitin-cnf.ts +485 -0
  480. package/src/prover/smt/solver/var-subst.ts +36 -14
  481. package/src/prover/smt/table.ts +3 -2
  482. package/src/prover/smt/types.ts +146 -0
  483. package/src/prover/tlapm/cache.ts +29 -8
  484. package/src/prover/tlapm-library.ts +3208 -0
  485. package/src/prover/verdict.ts +2 -0
  486. package/src/prover/zenon/decide.ts +10 -7
  487. package/src/prover/zenon/encode.ts +0 -2
  488. package/src/prover/zenon/eqrel.ts +0 -2
  489. package/src/prover/zenon/equality-rules.ts +24 -2
  490. package/src/prover/zenon/expr.ts +21 -2
  491. package/src/prover/zenon/index-table.ts +7 -4
  492. package/src/prover/zenon/isar-case.ts +1 -3
  493. package/src/prover/zenon/isar.ts +2 -4
  494. package/src/prover/zenon/llproof.ts +0 -2
  495. package/src/prover/zenon/mltoll.ts +0 -2
  496. package/src/prover/zenon/node.ts +20 -5
  497. package/src/prover/zenon/parse.ts +6 -2
  498. package/src/prover/zenon/phrase.ts +1 -3
  499. package/src/prover/zenon/proof.ts +0 -2
  500. package/src/prover/zenon/propositional-rules.ts +0 -2
  501. package/src/prover/zenon/rules.ts +2 -3
  502. package/src/prover/zenon/search.ts +7 -5
  503. package/src/prover/zenon/tla/functions.ts +0 -2
  504. package/src/prover/zenon/tla/llproof.ts +0 -2
  505. package/src/prover/zenon/tla/records.ts +0 -2
  506. package/src/prover/zenon/tla/rewrites.ts +0 -2
  507. package/src/prover/zenon/tla/sets.ts +7 -8
  508. package/src/prover/zenon/tla/terms.ts +0 -2
  509. package/src/prover/zenon/tla/tla.ts +0 -2
  510. package/src/resolve.ts +264 -77
  511. package/src/runtime.ts +6 -0
  512. package/src/sany/generation.ts +1 -13
  513. package/src/sany/generator-definitions.ts +2 -1
  514. package/src/sany/generator-expressions.ts +30 -27
  515. package/src/sany/generator-proofs.ts +1 -1
  516. package/src/sany/generator.ts +2 -1
  517. package/src/sany/levels.ts +0 -2
  518. package/src/sany/linter.ts +0 -2
  519. package/src/sany/nodes.ts +1 -1
  520. package/src/sany/selectors.ts +6 -5
  521. package/src/search.ts +209 -56
  522. package/src/simulate.ts +3 -0
  523. package/src/spec-description.ts +2 -2
  524. package/src/standard-definitions.ts +4 -0
  525. package/src/state-graph.ts +0 -2
  526. package/src/subexpressions.ts +165 -78
  527. package/src/successors.ts +2 -1
  528. package/src/symmetry.ts +2 -2
  529. package/src/tableau.ts +2 -2
  530. package/src/tlc/fingerprint.ts +81 -9
  531. package/src/tlc/jar-data.ts +12 -0
  532. package/src/tlc/order.ts +14 -3
  533. package/src/tlc/summary.ts +29 -14
  534. package/src/tlc/tlcext-operators.ts +61 -16
  535. package/src/tlc/trace-spec.ts +2 -3
  536. package/src/typed-tier.ts +6541 -0
  537. package/src/typescript/types.ts +2 -2
  538. package/src/values.ts +42 -23
  539. package/src/prover/isabelle/isar/statement.ts +0 -52
  540. package/src/prover/smt/solver/z3-license.txt +0 -10
  541. package/src/prover/tlaps-module.ts +0 -510
  542. package/src/prover/zenon/LICENSE +0 -32
package/src/parser.ts CHANGED
@@ -35,6 +35,24 @@ interface InfixOperator extends Precedence {
35
35
  isAssociative: boolean;
36
36
  }
37
37
 
38
+ interface TlapmOperand {
39
+ start: number;
40
+ end: number;
41
+ expression: Expression;
42
+ joinedBy?: string;
43
+ }
44
+
45
+ interface TlapmOperator extends Precedence {
46
+ start: number;
47
+ end: number;
48
+ fixity: "Prefix" | "Infix" | "Postfix";
49
+ isLeft: boolean;
50
+ joins?: string;
51
+ apply: (operands: TlapmOperand[]) => Expression;
52
+ }
53
+
54
+ type TlapmItem = TlapmOperand | TlapmOperator;
55
+
38
56
  const POSTFIX_PRECEDENCE = { low: 15, high: 15 };
39
57
  const FUNCTION_PRECEDENCE = { low: 16, high: 16 };
40
58
 
@@ -144,6 +162,49 @@ const INFIX_OPERATORS = new Map<string, InfixOperator>([
144
162
 
145
163
  const NEGATION_PRECEDENCE = 12;
146
164
 
165
+ // tlapm's Optable has SANY's infix precedences, groups % and \X to the left with the operators
166
+ // SANY takes as associative, and has these prefix precedences. A function application and a field
167
+ // bind above every operator.
168
+ const isTlapmLeft = (text: string, infix: InfixOperator) =>
169
+ infix.isAssociative || text === "%" || text === "\\X";
170
+
171
+ const TLAPM_PREFIX_OPERATORS = new Map<string, Precedence>([
172
+ ["~", { low: 4, high: 4 }],
173
+ ["[]", { low: 4, high: 15 }],
174
+ ["<>", { low: 4, high: 15 }],
175
+ ["ENABLED", { low: 4, high: 15 }],
176
+ ["UNCHANGED", { low: 4, high: 15 }],
177
+ ["SUBSET", { low: 8, high: 8 }],
178
+ ["UNION", { low: 8, high: 8 }],
179
+ ["DOMAIN", { low: 9, high: 9 }],
180
+ ["-", { low: 12, high: 12 }],
181
+ ["-.", { low: 12, high: 12 }],
182
+ ]);
183
+
184
+ const TLAPM_SELECTION_PRECEDENCE = { low: 17, high: 17 };
185
+
186
+ const TLAPM_ATOM_STARTS = new Set([
187
+ "(",
188
+ "[",
189
+ "{",
190
+ "<<",
191
+ "@",
192
+ "\\A",
193
+ "\\E",
194
+ "\\AA",
195
+ "\\EE",
196
+ "IF",
197
+ "CASE",
198
+ "LET",
199
+ "CHOOSE",
200
+ "LAMBDA",
201
+ "WF_",
202
+ "SF_",
203
+ ]);
204
+
205
+ // The brackets whose contents tlapm reads without committing, so a failure in them backtracks.
206
+ const TLAPM_OPEN_BRACKETS = new Set(["(", "{", "<<"]);
207
+
147
208
  const POSTFIX_OPERATORS = new Set(["^+", "^*", "^#"]);
148
209
 
149
210
  const DEFINABLE_POSTFIX_OPERATORS = new Set([...POSTFIX_OPERATORS, "'"]);
@@ -315,13 +376,30 @@ const getSpan = (range: SourceRange): Span => ({
315
376
  stop: { line: range.end.line, column: range.end.column + 1 },
316
377
  });
317
378
 
318
- const createProofError = (message: string, span: Span, exception = "Proof.Parser") =>
379
+ interface ProofErrorEnds {
380
+ printed: string;
381
+ set: string;
382
+ }
383
+
384
+ const NO_NEWLINES: ProofErrorEnds = { printed: "", set: "" };
385
+
386
+ const PRINTED_NEWLINE: ProofErrorEnds = { printed: "\n", set: "" };
387
+
388
+ const NEWLINES: ProofErrorEnds = { printed: "\n", set: "\n" };
389
+
390
+ // p_parser.ml ends some of the messages it prints, and of those it sets, with a newline.
391
+ const createProofError = (
392
+ message: string,
393
+ span: Span,
394
+ ends: ProofErrorEnds,
395
+ exception = "Proof.Parser",
396
+ ) =>
319
397
  new TlaSyntaxError(message, undefined, {
320
- reason: message,
398
+ reason: `${message}${ends.set}`,
321
399
  line: span.start.line,
322
400
  column: span.start.column,
323
401
  isEnd: false,
324
- proof: { stop: span.stop, exception },
402
+ proof: { stop: span.stop, exception, printed: `${message}${ends.printed}` },
325
403
  });
326
404
 
327
405
  const FACT_KEYWORDS = new Set([
@@ -426,6 +504,11 @@ const parse = (
426
504
  const factNames = new Set<string>();
427
505
  const proofScopes: Set<string>[] = [];
428
506
  const openModules: Module[] = [];
507
+ // Pco's backtracking: a failure not past a commit rewinds to its attempt's frame.
508
+ let attemptFrame: number | undefined;
509
+ let attemptCount = 0;
510
+ const restorePoints: number[] = [];
511
+ const backtracks = new WeakMap<TlaSyntaxError, number>();
429
512
 
430
513
  const isRecursiveName = (name: string) => recursiveScopes[recursiveScopes.length - 1].has(name);
431
514
 
@@ -473,15 +556,6 @@ const parse = (
473
556
  const describeToken = (token: Token) =>
474
557
  token.kind === "End" ? "end of input" : JSON.stringify(token.text);
475
558
 
476
- let unitStart = 0;
477
-
478
- const getDefinitionEnd = (fallback: Point) => {
479
- const equals = tokens
480
- .slice(unitStart, cursor)
481
- .find((token) => token.text === "==" && token.kind !== "String");
482
- return equals ? { line: equals.line, column: equals.endColumn + 1 } : fallback;
483
- };
484
-
485
559
  const isTlapmKeyword = (token: Token) =>
486
560
  isTlapm && (token.kind === "Keyword" || BUILTIN_CONSTANTS.has(token.text));
487
561
 
@@ -496,6 +570,7 @@ const parse = (
496
570
  };
497
571
 
498
572
  const getTlapmName = (token: Token) => {
573
+ if (token.kind === "End") return "EOF";
499
574
  if (/^-{4,}$/.test(token.text)) return "----";
500
575
  if (/^={4,}$/.test(token.text)) return "====";
501
576
  if (TLAPM_PUNCTUATION.has(token.text) || token.kind === "Number" || token.kind === "Decimal")
@@ -509,36 +584,76 @@ const parse = (
509
584
  const createError = (message: string, token: Point = peekRaw(), unexpected?: Token) => {
510
585
  const end = tokens[tokens.length - 1];
511
586
  const isEnd = token.line === end.line && token.column === end.column;
512
- return new TlaSyntaxError(
587
+ const error = new TlaSyntaxError(
513
588
  `${message} at line ${token.line}, column ${token.column}`,
514
589
  undefined,
515
590
  getFailure(message, token, isEnd, unexpected),
516
591
  );
592
+ if (attemptFrame !== undefined) backtracks.set(error, attemptFrame);
593
+ return error;
517
594
  };
518
595
 
596
+ // tlapm reports a failure after the last token it read before the outermost attempt around it.
519
597
  const getFailure = (
520
598
  message: string,
521
599
  token: Point,
522
600
  isEnd: boolean,
523
601
  unexpected: Token | undefined,
524
602
  ) => {
525
- if (isTlapm && isEnd) {
526
- const end = tokens[tokens.length - 1];
527
- return { reason: "Unexpected EOF", ...getDefinitionEnd(getPreviousEnd(end)), isEnd };
528
- }
529
- if (isTlapm && unexpected) {
530
- return {
531
- reason: `Unexpected ${getTlapmName(unexpected)}`,
532
- ...getPreviousEnd(unexpected),
533
- isEnd,
534
- };
535
- }
536
- return { reason: message, line: token.line, column: token.column, isEnd };
603
+ if (!isTlapm) return { reason: message, line: token.line, column: token.column, isEnd };
604
+ const restored = tokens[restorePoints[0] - 1];
605
+ const reason = unexpected ? `Unexpected ${getTlapmName(unexpected)}` : message;
606
+ if (restored) return { reason, line: restored.line, column: restored.endColumn + 1, isEnd };
607
+ const position = unexpected ? getPreviousEnd(unexpected) : token;
608
+ return { reason, line: position.line, column: position.column, isEnd };
537
609
  };
538
610
 
539
611
  const createUnexpected = (message: string, token: Token = peekRaw()) =>
540
612
  createError(message, token, token);
541
613
 
614
+ // Pco.attempt: a failure that backtracks to it leaves the input as it was, and gives undefined.
615
+ const attempt = <Result>(parse: () => Result): Result | undefined => {
616
+ const saved = {
617
+ cursor,
618
+ frame: attemptFrame,
619
+ restorePoints: restorePoints.length,
620
+ offsideColumns: offsideColumns.length,
621
+ recursiveScopes: recursiveScopes.length,
622
+ };
623
+ const frame = ++attemptCount;
624
+ attemptFrame = frame;
625
+ try {
626
+ const result = parse();
627
+ attemptFrame = saved.frame;
628
+ return result;
629
+ } catch (error) {
630
+ if (!(error instanceof TlaSyntaxError) || backtracks.get(error) !== frame) throw error;
631
+ cursor = saved.cursor;
632
+ attemptFrame = saved.frame;
633
+ restorePoints.length = saved.restorePoints;
634
+ offsideColumns.length = saved.offsideColumns;
635
+ recursiveScopes.length = saved.recursiveScopes;
636
+ return undefined;
637
+ }
638
+ };
639
+
640
+ // Pco.commit: a failure in parse no longer backtracks.
641
+ const commit = <Result>(parse: () => Result) => {
642
+ const frame = attemptFrame;
643
+ attemptFrame = undefined;
644
+ const result = parse();
645
+ attemptFrame = frame;
646
+ return result;
647
+ };
648
+
649
+ const withRestorePoint = <Result>(parse: () => Result) => {
650
+ restorePoints.push(cursor);
651
+ const result = parse();
652
+ restorePoints.pop();
653
+ return result;
654
+ };
655
+
656
+ // Deviation from SANY: TLAplusParser#belchDEF reads a field named THEOREM, AXIOM, DOMAIN or a like keyword as that keyword, so SANY rejects the definition after it.
542
657
  const isFieldName = (token: Token) =>
543
658
  (token.kind === "Identifier" ||
544
659
  token.kind === "Keyword" ||
@@ -552,7 +667,7 @@ const parse = (
552
667
 
553
668
  const advance = () => {
554
669
  const token = peek();
555
- if (token.kind === "End") throw createError("Unexpected end of expression");
670
+ if (token.kind === "End") throw createUnexpected("Unexpected end of expression");
556
671
  cursor++;
557
672
  return token;
558
673
  };
@@ -622,13 +737,13 @@ const parse = (
622
737
  return items;
623
738
  };
624
739
 
625
- const isBoundAhead = () => {
626
- if (isAt("<<")) {
627
- let offset = 1;
740
+ const isBoundAhead = (start = 0) => {
741
+ if (isAt("<<", start)) {
742
+ let offset = start + 1;
628
743
  while (peek(offset).kind === "Identifier" || isAt(",", offset)) offset++;
629
744
  return isAt(">>", offset) && isAt("\\in", offset + 1);
630
745
  }
631
- let offset = 0;
746
+ let offset = start;
632
747
  while (peek(offset).kind === "Identifier") {
633
748
  if (isAt("\\in", offset + 1)) return true;
634
749
  if (!isAt(",", offset + 1)) return false;
@@ -655,13 +770,21 @@ const parse = (
655
770
  return { kind: "Tuple", names: names.names, ranges: names.ranges };
656
771
  };
657
772
 
658
- const parseBounds = () =>
659
- parseSeparated(() => {
773
+ // tlapm's func_boundeds reads another bound only where names and \in follow the comma.
774
+ const parseBounds = () => {
775
+ const parseBound = () => {
660
776
  const patterns = parseSeparated(parsePattern);
661
777
  expect("\\in");
662
- const set = parseExpression();
778
+ const set = commit(parseExpression);
663
779
  return patterns.map((pattern) => ({ pattern, set }));
664
- }).flat();
780
+ };
781
+ const bounds = [parseBound()];
782
+ while (isAt(",") && (!isTlapm || isBoundAhead(1))) {
783
+ advance();
784
+ bounds.push(parseBound());
785
+ }
786
+ return bounds.flat();
787
+ };
665
788
 
666
789
  const parseSubscript = (): { subscript: Expression; lastArgs: Expression[] } => {
667
790
  const token = peek();
@@ -823,7 +946,11 @@ const parse = (
823
946
  start,
824
947
  );
825
948
  }
826
- return parseExpression();
949
+ if (!isTlapm) return parseExpression();
950
+ // tlapm's oparg reads an operator where an expression doesn't start, and fails otherwise.
951
+ const argument = attempt(parseExpression);
952
+ if (argument) return argument;
953
+ throw createUnexpected(`Unexpected ${describeToken(peek())}`);
827
954
  };
828
955
 
829
956
  let lastArgumentsRange: SourceRange | undefined;
@@ -842,14 +969,19 @@ const parse = (
842
969
  const bullet = advance();
843
970
  offsideColumns.push(bullet.column);
844
971
  const operands = [parseExpression()];
845
- while (
846
- isBullet(peekRaw()) &&
847
- peekRaw().text === bullet.text &&
848
- peekRaw().column === bullet.column
849
- ) {
850
- cursor++;
851
- operands.push(parseExpression());
852
- }
972
+ const parseItems = () => {
973
+ while (
974
+ isBullet(peekRaw()) &&
975
+ peekRaw().text === bullet.text &&
976
+ peekRaw().column === bullet.column
977
+ ) {
978
+ cursor++;
979
+ operands.push(parseExpression());
980
+ }
981
+ };
982
+ // bulleted_list: a first item that fails leaves expr_or_op's other readings to fail after it.
983
+ if (isTlapm) commit(parseItems);
984
+ else parseItems();
853
985
  offsideColumns.pop();
854
986
  return {
855
987
  kind: bullet.text === "/\\" ? "And" : "Or",
@@ -940,7 +1072,7 @@ const parse = (
940
1072
  const element = withRange(parsePrefix(), start);
941
1073
  const location = getLocation(advance());
942
1074
  return withRange(
943
- { kind: "Apply", operator: "\\in", args: [element, parseExpression()], location },
1075
+ { kind: "Apply", operator: "\\in", args: [element, commit(parseExpression)], location },
944
1076
  start,
945
1077
  );
946
1078
  };
@@ -953,9 +1085,9 @@ const parse = (
953
1085
  const checkpoint = cursor;
954
1086
  const pattern = parsePattern();
955
1087
  expect("\\in");
956
- const set = parseExpression();
1088
+ const set = commit(parseExpression);
957
1089
  if (accept(":")) {
958
- const predicate = parseExpression();
1090
+ const predicate = commit(parseExpression);
959
1091
  expect("}");
960
1092
  return { kind: "SetFilter", bound: { pattern, set }, predicate, location };
961
1093
  }
@@ -985,7 +1117,7 @@ const parse = (
985
1117
  return {
986
1118
  kind: "AngleAction",
987
1119
  action: elements[0],
988
- subscript: parseSubscript().subscript,
1120
+ subscript: commit(parseSubscript).subscript,
989
1121
  location,
990
1122
  };
991
1123
  }
@@ -1070,6 +1202,49 @@ const parse = (
1070
1202
  return { kind: "Name", name: token.text, args: isAt("(") ? parseArguments() : [] };
1071
1203
  };
1072
1204
 
1205
+ const parseSelections = (
1206
+ name: string,
1207
+ args: Expression[],
1208
+ argumentsRange: SourceRange | undefined,
1209
+ start: number,
1210
+ location: SourceLocation,
1211
+ ): Expression => {
1212
+ const selectors: Selector[] = [{ kind: "Name", name, args }];
1213
+ const selectorRanges = [getRange(start, start)];
1214
+ const argumentRanges = [argumentsRange];
1215
+ while (isSelectorAhead()) {
1216
+ advance();
1217
+ selectorRanges.push(getRange(cursor, cursor));
1218
+ lastArgumentsRange = undefined;
1219
+ selectors.push(parseSelector());
1220
+ argumentRanges.push(lastArgumentsRange);
1221
+ }
1222
+ const names = selectors.flatMap((selector) =>
1223
+ selector.kind === "Name" ? [selector.name] : [],
1224
+ );
1225
+ const operator = names.join("!");
1226
+ const qualifiedArgs = selectors.flatMap((selector) =>
1227
+ "args" in selector ? selector.args : [],
1228
+ );
1229
+ const argumentCounts = selectors.map((selector) =>
1230
+ "args" in selector ? selector.args.length : 0,
1231
+ );
1232
+ return names.length < selectors.length
1233
+ ? { kind: "Subexpression", selectors, selectorRanges, argumentRanges, location }
1234
+ : qualifiedArgs.length === 0
1235
+ ? { kind: "Identifier", name: operator, selectorRanges, location }
1236
+ : {
1237
+ kind: "Apply",
1238
+ operator,
1239
+ args: qualifiedArgs,
1240
+ ...(argumentCounts.slice(0, -1).some((count) => count > 0) && { argumentCounts }),
1241
+ argumentsRange: argumentRanges.at(-1) ?? getRange(start),
1242
+ selectorRanges,
1243
+ argumentRanges,
1244
+ location,
1245
+ };
1246
+ };
1247
+
1073
1248
  const parsePrimary = (preceding?: Precedence): Expression => {
1074
1249
  const start = cursor;
1075
1250
  const token = advance();
@@ -1079,10 +1254,8 @@ const parse = (
1079
1254
  expect(":");
1080
1255
  return { kind: "Lambda", params, body: parseExpression(), location };
1081
1256
  }
1082
- if (token.kind === "Number") {
1083
- if (isTlapm && /^\\[BOH]/.test(token.text)) throw createError("incomplete expression", token);
1257
+ if (token.kind === "Number")
1084
1258
  return { kind: "Number", value: getNumeralValue(token.text), text: token.text, location };
1085
- }
1086
1259
  if (token.kind === "Decimal") return { kind: "Decimal", text: token.text, location };
1087
1260
  if (token.kind === "String") return { kind: "String", value: token.text, location };
1088
1261
  const isStep = token.kind === "Step" && isStepReference(token);
@@ -1123,56 +1296,45 @@ const parse = (
1123
1296
  if (name === "@" && !hasArguments && !isSelectorAhead())
1124
1297
  return { kind: "ExceptAt", location };
1125
1298
  const args = hasArguments ? parseArguments() : [];
1126
- const argumentRanges = [hasArguments ? lastArgumentsRange : undefined];
1127
1299
  if (!isSelectorAhead()) {
1128
1300
  return hasArguments
1129
1301
  ? { kind: "Apply", operator: name, args, argumentsRange: lastArgumentsRange, location }
1130
1302
  : { kind: "Identifier", name, location };
1131
1303
  }
1132
- const selectors: Selector[] = [{ kind: "Name", name, args }];
1133
- const selectorRanges = [getRange(start, start)];
1134
- while (isSelectorAhead()) {
1135
- advance();
1136
- selectorRanges.push(getRange(cursor, cursor));
1137
- lastArgumentsRange = undefined;
1138
- selectors.push(parseSelector());
1139
- argumentRanges.push(lastArgumentsRange);
1140
- }
1141
- const names = selectors.flatMap((selector) =>
1142
- selector.kind === "Name" ? [selector.name] : [],
1143
- );
1144
- const operator = names.join("!");
1145
- const qualifiedArgs = selectors.flatMap((selector) =>
1146
- "args" in selector ? selector.args : [],
1147
- );
1148
- const argumentCounts = selectors.map((selector) =>
1149
- "args" in selector ? selector.args.length : 0,
1304
+ return parseSelections(
1305
+ name,
1306
+ args,
1307
+ hasArguments ? lastArgumentsRange : undefined,
1308
+ start,
1309
+ location,
1150
1310
  );
1151
- const argumentsRange = argumentRanges.at(-1) ?? getRange(start);
1152
- return names.length < selectors.length
1153
- ? { kind: "Subexpression", selectors, selectorRanges, argumentRanges, location }
1154
- : qualifiedArgs.length === 0
1155
- ? { kind: "Identifier", name: operator, selectorRanges, location }
1156
- : {
1157
- kind: "Apply",
1158
- operator,
1159
- args: qualifiedArgs,
1160
- ...(argumentCounts.slice(0, -1).some((count) => count > 0) && { argumentCounts }),
1161
- argumentsRange,
1162
- selectorRanges,
1163
- argumentRanges,
1164
- location,
1165
- };
1166
1311
  }
1167
- if (token.kind === "Operator" && isOperatorName(token.text) && isAt("(")) {
1312
+ const isOperatorNamed =
1313
+ token.kind === "Operator" && (isOperatorName(token.text) || (token.text === "'" && !isTlapm));
1314
+ if (isOperatorNamed && isAt("(")) {
1168
1315
  const args = parseArguments();
1316
+ if (!isTlapm && isSelectorAhead()) {
1317
+ return parseSelections(token.text, args, lastArgumentsRange, start, location);
1318
+ }
1169
1319
  // Deviation from TLC: SANY's built-in \X has no definition for TLC to evaluate, a TLC bug.
1170
- return mode === "tlc" && token.text === "\\X" && args.length === 2
1171
- ? { kind: "Product", factors: args, location }
1172
- : { kind: "Apply", operator: token.text, spelling: token.spelling, args, location };
1320
+ if (mode === "tlc" && token.text === "\\X" && args.length === 2) {
1321
+ return { kind: "Product", factors: args, location };
1322
+ }
1323
+ return token.text === "'" && args.length === 1
1324
+ ? { kind: "Prime", expression: args[0], location }
1325
+ : {
1326
+ kind: "Apply",
1327
+ operator: token.text,
1328
+ spelling: token.spelling,
1329
+ args,
1330
+ argumentsRange: lastArgumentsRange,
1331
+ location,
1332
+ };
1173
1333
  }
1174
- if (token.kind === "Operator" && isOperatorName(token.text) && !isTlapm) {
1175
- return { kind: "Identifier", name: token.text, spelling: token.spelling, location };
1334
+ if (isOperatorNamed && !isTlapm) {
1335
+ return isSelectorAhead()
1336
+ ? parseSelections(token.text, [], undefined, start, location)
1337
+ : { kind: "Identifier", name: token.text, spelling: token.spelling, location };
1176
1338
  }
1177
1339
  switch (token.text) {
1178
1340
  case "(": {
@@ -1207,8 +1369,7 @@ const parse = (
1207
1369
  const instances: Instance[] = [];
1208
1370
  recursiveScopes.push(new Set());
1209
1371
  while (!accept("IN")) {
1210
- if (isTlapm && isAt("RECURSIVE"))
1211
- throw createError("Unexpected keyword RECURSIVE", getDefinitionEnd(peekRaw()));
1372
+ if (isTlapm && isAt("RECURSIVE")) throw createUnexpected("Unexpected keyword RECURSIVE");
1212
1373
  if (accept("RECURSIVE")) {
1213
1374
  declareRecursive();
1214
1375
  continue;
@@ -1254,14 +1415,12 @@ const parse = (
1254
1415
 
1255
1416
  const parsePrefixOperand = (operator: Token, low: number, high: number) => {
1256
1417
  lastOperator = precedingOperator = { low, high };
1257
- const operand = parseExpression(
1258
- isTlapm ? Math.min(high + 1, POSTFIX_PRECEDENCE.low) : high + 1,
1259
- );
1418
+ const operand = parseExpression(high + 1);
1260
1419
  const next = peek();
1261
1420
  const nextHigh = DEFINABLE_POSTFIX_OPERATORS.has(next.text)
1262
1421
  ? POSTFIX_PRECEDENCE.high
1263
1422
  : INFIX_OPERATORS.get(next.text)?.high;
1264
- if (!isTlapm && next.kind === "Operator" && nextHigh !== undefined && nextHigh >= low) {
1423
+ if (next.kind === "Operator" && nextHigh !== undefined && nextHigh >= low) {
1265
1424
  throw createError(`Precedence conflict between ${operator.text} and ${next.text}`, next);
1266
1425
  }
1267
1426
  return operand;
@@ -1275,26 +1434,6 @@ const parse = (
1275
1434
  if (token.kind === "Operator" && isBullet(token)) {
1276
1435
  return parseJunctionList();
1277
1436
  }
1278
- if (isTlapm && INFIX_OPERATORS.has(token.text) && isAt("(", 1)) {
1279
- const start = cursor;
1280
- const nonfix = withBracketLayout(() => {
1281
- advance();
1282
- advance();
1283
- const left = parseExpression();
1284
- if (!accept(",")) return undefined;
1285
- const right = parseExpression();
1286
- expect(")");
1287
- const apply: Expression = {
1288
- kind: "Apply",
1289
- operator: token.text,
1290
- args: [left, right],
1291
- location,
1292
- };
1293
- return withRange(apply, start);
1294
- });
1295
- if (nonfix !== undefined) return nonfix;
1296
- cursor = start;
1297
- }
1298
1437
  if (token.kind === "Operator" || token.kind === "Keyword") {
1299
1438
  switch (token.text) {
1300
1439
  case "~":
@@ -1306,8 +1445,6 @@ const parse = (
1306
1445
  location,
1307
1446
  };
1308
1447
  case "-":
1309
- case "-.":
1310
- if (token.text === "-." && !isTlapm) break;
1311
1448
  advance();
1312
1449
  return {
1313
1450
  kind: "Apply",
@@ -1328,7 +1465,7 @@ const parse = (
1328
1465
  return {
1329
1466
  kind: "Apply",
1330
1467
  operator: token.text,
1331
- args: [isTlapm ? parseExpression(9) : parsePrefixOperand(token, 10, 13)],
1468
+ args: [parsePrefixOperand(token, 10, 13)],
1332
1469
  location,
1333
1470
  };
1334
1471
  }
@@ -1336,7 +1473,57 @@ const parse = (
1336
1473
  return parsePrimary(preceding);
1337
1474
  };
1338
1475
 
1339
- const parseExpression = (minimumPrecedence = 0): Expression => {
1476
+ const getInfixApplication = (
1477
+ token: Token,
1478
+ left: Expression,
1479
+ right: Expression,
1480
+ isChained: boolean,
1481
+ prefixEnd: Point,
1482
+ ): Expression => {
1483
+ const location = getLocation(token);
1484
+ if (token.text === "/\\" || token.text === "\\/") {
1485
+ const kind = token.text === "/\\" ? "And" : "Or";
1486
+ return left.kind === kind && isChained
1487
+ ? {
1488
+ ...left,
1489
+ operands: [...left.operands, right],
1490
+ prefixEnds: [...(left.prefixEnds ?? []), prefixEnd],
1491
+ }
1492
+ : { kind, operands: [left, right], prefixEnds: [prefixEnd], location };
1493
+ }
1494
+ if (token.text === "\\X") {
1495
+ return left.kind === "Product" && isChained
1496
+ ? { ...left, factors: [...left.factors, right] }
1497
+ : { kind: "Product", factors: [left, right], location };
1498
+ }
1499
+ return {
1500
+ kind: "Apply",
1501
+ operator: token.text,
1502
+ spelling: token.spelling,
1503
+ args: [left, right],
1504
+ location,
1505
+ };
1506
+ };
1507
+
1508
+ const getPostfixApplication = (token: Token, operand: Expression): Expression =>
1509
+ token.text === "'"
1510
+ ? { kind: "Prime", expression: operand, location: getLocation(token) }
1511
+ : {
1512
+ kind: "Apply",
1513
+ operator: token.text,
1514
+ spelling: token.spelling,
1515
+ args: [operand],
1516
+ location: getLocation(token),
1517
+ };
1518
+
1519
+ const parseFunctionArguments = () => {
1520
+ advance();
1521
+ const args = withBracketLayout(() => parseSeparated(() => parseExpression()));
1522
+ withBracketLayout(() => expect("]"));
1523
+ return args;
1524
+ };
1525
+
1526
+ const parseSanyExpression = (minimumPrecedence: number): Expression => {
1340
1527
  const start = cursor;
1341
1528
  const prefix = parsePrefix();
1342
1529
  let left = prefix.location.range ? prefix : withRange(prefix, start);
@@ -1345,31 +1532,14 @@ const parse = (
1345
1532
  const token = peek();
1346
1533
  if (token.kind !== "Operator") break;
1347
1534
  const location = getLocation(token);
1348
- if (token.text === "'" && minimumPrecedence <= 15) {
1535
+ if (DEFINABLE_POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
1349
1536
  advance();
1350
1537
  lastOperator = POSTFIX_PRECEDENCE;
1351
- left = withRange({ kind: "Prime", expression: left, location }, start);
1352
- continue;
1353
- }
1354
- if (POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
1355
- advance();
1356
- lastOperator = POSTFIX_PRECEDENCE;
1357
- left = withRange(
1358
- {
1359
- kind: "Apply",
1360
- operator: token.text,
1361
- spelling: token.spelling,
1362
- args: [left],
1363
- location,
1364
- },
1365
- start,
1366
- );
1538
+ left = withRange(getPostfixApplication(token, left), start);
1367
1539
  continue;
1368
1540
  }
1369
1541
  if (token.text === "[") {
1370
- advance();
1371
- const args = withBracketLayout(() => parseSeparated(() => parseExpression()));
1372
- withBracketLayout(() => expect("]"));
1542
+ const args = parseFunctionArguments();
1373
1543
  lastOperator = FUNCTION_PRECEDENCE;
1374
1544
  left = withRange({ kind: "FunctionApplication", function: left, args, location }, start);
1375
1545
  continue;
@@ -1393,42 +1563,260 @@ const parse = (
1393
1563
  }
1394
1564
  }
1395
1565
  advance();
1396
- if (!isTlapm && infix.low > NEGATION_PRECEDENCE && isAt("-")) {
1566
+ if (infix.low > NEGATION_PRECEDENCE && isAt("-")) {
1397
1567
  throw createError(`Precedence conflict between ${token.text} and -`, peek());
1398
1568
  }
1399
1569
  lastOperator = precedingOperator = infix;
1400
1570
  const right = parseExpression(infix.high + 1);
1401
- if (token.text === "/\\" || token.text === "\\/") {
1402
- const kind = token.text === "/\\" ? "And" : "Or";
1403
- const prefixEnds = [getRange(start).end];
1404
- left =
1405
- left.kind === kind && previous?.text === token.text
1406
- ? {
1407
- ...left,
1408
- operands: [...left.operands, right],
1409
- prefixEnds: [...(left.prefixEnds ?? []), ...prefixEnds],
1410
- }
1411
- : { kind, operands: [left, right], prefixEnds, location };
1412
- } else if (token.text === "\\X") {
1413
- left =
1414
- left.kind === "Product" && previous?.text === "\\X"
1415
- ? { ...left, factors: [...left.factors, right] }
1416
- : { kind: "Product", factors: [left, right], location };
1417
- } else {
1418
- left = {
1419
- kind: "Apply",
1420
- operator: token.text,
1421
- spelling: token.spelling,
1422
- args: [left, right],
1571
+ const isChained = previous?.text === token.text;
1572
+ left = withRange(
1573
+ getInfixApplication(token, left, right, isChained, getRange(start).end),
1574
+ start,
1575
+ );
1576
+ previous = { ...infix, text: token.text };
1577
+ }
1578
+ return left;
1579
+ };
1580
+
1581
+ const isTlapmAtomStart = (token: Token) =>
1582
+ token.kind === "Number" ||
1583
+ token.kind === "Decimal" ||
1584
+ token.kind === "String" ||
1585
+ token.kind === "Identifier" ||
1586
+ (token.kind === "Step" && isStepReference(token) && /^<\d/.test(token.text)) ||
1587
+ ((token.kind === "Operator" || token.kind === "Keyword") && TLAPM_ATOM_STARTS.has(token.text));
1588
+
1589
+ const getTlapmOperand = (expression: Expression, start: number): TlapmOperand => ({
1590
+ start,
1591
+ end: cursor - 1,
1592
+ expression: expression.location.range ? expression : withRange(expression, start),
1593
+ });
1594
+
1595
+ const getTlapmOperator = (
1596
+ start: number,
1597
+ fixity: TlapmOperator["fixity"],
1598
+ precedence: Precedence,
1599
+ apply: TlapmOperator["apply"],
1600
+ ): TlapmOperator => ({
1601
+ ...precedence,
1602
+ start,
1603
+ end: cursor - 1,
1604
+ fixity,
1605
+ isLeft: false,
1606
+ apply,
1607
+ });
1608
+
1609
+ // expr_or_op's non_test: a postfix operator before an expression in parentheses is an atom.
1610
+ const parseTlapmNonfixPostfix = (token: Token) =>
1611
+ token.kind === "Operator" && DEFINABLE_POSTFIX_OPERATORS.has(token.text) && isAt("(", 1)
1612
+ ? attempt(() =>
1613
+ withBracketLayout(() => {
1614
+ advance();
1615
+ advance();
1616
+ const operand = parseExpression();
1617
+ const end = cursor - 1;
1618
+ expect(")");
1619
+ return { end, expression: getPostfixApplication(token, operand) };
1620
+ }),
1621
+ )
1622
+ : undefined;
1623
+
1624
+ // A comma directly inside the parentheses after the operator, without which non_test's
1625
+ // attempt at `(e, f)` fails. A selector's << or >> isn't a bracket.
1626
+ const hasNonfixComma = () => {
1627
+ let depth = 0;
1628
+ for (let index = cursor + 1; index < tokens.length; index++) {
1629
+ const token = tokens[index];
1630
+ if (token.kind !== "Operator") continue;
1631
+ if (depth === 1 && token.text === ",") return true;
1632
+ if (tokens[index - 1].text === "!") continue;
1633
+ if (OPENING_BRACKETS.has(token.text)) depth++;
1634
+ if (CLOSING_BRACKETS.has(token.text) && --depth === 0) return false;
1635
+ }
1636
+ return false;
1637
+ };
1638
+
1639
+ // expr_or_op's non_test: an infix operator before two expressions in parentheses is an atom.
1640
+ const parseTlapmNonfixInfix = (token: Token) =>
1641
+ isAt("(", 1) && hasNonfixComma()
1642
+ ? attempt(() =>
1643
+ withBracketLayout((): Expression => {
1644
+ advance();
1645
+ advance();
1646
+ const left = parseExpression();
1647
+ expect(",");
1648
+ const right = parseExpression();
1649
+ expect(")");
1650
+ return {
1651
+ kind: "Apply",
1652
+ operator: token.text,
1653
+ args: [left, right],
1654
+ location: getLocation(token),
1655
+ };
1656
+ }),
1657
+ )
1658
+ : undefined;
1659
+
1660
+ const parseTlapmItem = (isStart: boolean): TlapmItem | undefined => {
1661
+ const start = cursor;
1662
+ const token = peek();
1663
+ const location = getLocation(token);
1664
+ const isOperator = token.kind === "Operator" || token.kind === "Keyword";
1665
+ const infix = isOperator ? INFIX_OPERATORS.get(token.text) : undefined;
1666
+ if (!isStart) {
1667
+ if (isAt("[")) {
1668
+ const args = parseFunctionArguments();
1669
+ return getTlapmOperator(start, "Postfix", TLAPM_SELECTION_PRECEDENCE, (operands) => ({
1670
+ kind: "FunctionApplication",
1671
+ function: operands[0].expression,
1672
+ args,
1673
+ location,
1674
+ }));
1675
+ }
1676
+ if (isAt(".") && isFieldName(peek(1))) {
1677
+ advance();
1678
+ const field = advance().text;
1679
+ return getTlapmOperator(start, "Postfix", TLAPM_SELECTION_PRECEDENCE, (operands) => ({
1680
+ kind: "FieldAccess",
1681
+ record: operands[0].expression,
1682
+ field,
1423
1683
  location,
1684
+ }));
1685
+ }
1686
+ if (infix) {
1687
+ // Pco.resolve has no operator to put before that atom, so the expression ends here.
1688
+ if (parseTlapmNonfixInfix(token)) {
1689
+ cursor = start;
1690
+ return undefined;
1691
+ }
1692
+ advance();
1693
+ return {
1694
+ ...getTlapmOperator(start, "Infix", infix, (operands) =>
1695
+ getInfixApplication(
1696
+ token,
1697
+ operands[0].expression,
1698
+ operands[1].expression,
1699
+ operands[0].joinedBy === token.text,
1700
+ getRange(operands[0].start, operands[1].end).end,
1701
+ ),
1702
+ ),
1703
+ isLeft: isTlapmLeft(token.text, infix),
1704
+ joins: token.text,
1424
1705
  };
1425
1706
  }
1426
- left = withRange(left, start);
1427
- previous = { ...infix, text: token.text };
1707
+ if (token.kind !== "Operator" || !DEFINABLE_POSTFIX_OPERATORS.has(token.text))
1708
+ return undefined;
1709
+ // Pco.resolve has no operator to put before that atom, so the expression ends here.
1710
+ if (parseTlapmNonfixPostfix(token)) {
1711
+ cursor = start;
1712
+ return undefined;
1713
+ }
1714
+ advance();
1715
+ return getTlapmOperator(start, "Postfix", POSTFIX_PRECEDENCE, (operands) =>
1716
+ getPostfixApplication(token, operands[0].expression),
1717
+ );
1428
1718
  }
1429
- return left;
1719
+ if (token.kind === "Operator" && isBullet(token))
1720
+ return getTlapmOperand(parseJunctionList(), start);
1721
+ const nonfix = infix ? parseTlapmNonfixInfix(token) : undefined;
1722
+ if (nonfix) return getTlapmOperand(nonfix, start);
1723
+ const nonfixPostfix = parseTlapmNonfixPostfix(token);
1724
+ if (nonfixPostfix) {
1725
+ nonfixPostfix.expression.location.range = getRange(start, nonfixPostfix.end);
1726
+ return { start, end: nonfixPostfix.end, expression: nonfixPostfix.expression };
1727
+ }
1728
+ const prefix = isOperator ? TLAPM_PREFIX_OPERATORS.get(token.text) : undefined;
1729
+ if (prefix) {
1730
+ advance();
1731
+ return getTlapmOperator(start, "Prefix", prefix, (operands) =>
1732
+ getOperatorApplication(
1733
+ token.text === "-" ? "-." : token.text,
1734
+ operands[0].expression,
1735
+ location,
1736
+ ),
1737
+ );
1738
+ }
1739
+ if (!isTlapmAtomStart(token)) return undefined;
1740
+ const isTransparent = token.kind === "Operator" && TLAPM_OPEN_BRACKETS.has(token.text);
1741
+ return getTlapmOperand(isTransparent ? parsePrimary() : commit(parsePrimary), start);
1430
1742
  };
1431
1743
 
1744
+ const isTlapmOperator = (item: TlapmItem | undefined): item is TlapmOperator =>
1745
+ item !== undefined && "fixity" in item;
1746
+
1747
+ const isTlapmOperand = (item: TlapmItem | undefined): item is TlapmOperand =>
1748
+ item !== undefined && !("fixity" in item);
1749
+
1750
+ const applyTlapmOperator = (operator: TlapmOperator, operands: TlapmOperand[]) => {
1751
+ const start = Math.min(operator.start, operands[0].start);
1752
+ const end = Math.max(operator.end, operands[operands.length - 1].end);
1753
+ const expression = operator.apply(operands);
1754
+ expression.location.range = getRange(start, end);
1755
+ return { start, end, expression, joinedBy: operator.joins };
1756
+ };
1757
+
1758
+ const reduceTlapmItems = (stack: TlapmItem[]) => {
1759
+ const right = stack.pop();
1760
+ const operator = stack.pop();
1761
+ if (!isTlapmOperand(right) || !isTlapmOperator(operator)) {
1762
+ throw createError("incomplete expression");
1763
+ }
1764
+ const left = operator.fixity === "Infix" ? stack.pop() : undefined;
1765
+ stack.push(applyTlapmOperator(operator, isTlapmOperand(left) ? [left, right] : [right]));
1766
+ };
1767
+
1768
+ const getPreviousOperator = (stack: TlapmItem[]) => {
1769
+ const previous = stack[stack.length - 2];
1770
+ return isTlapmOperator(previous) ? previous : undefined;
1771
+ };
1772
+
1773
+ const isBelow = (left: Precedence, right: Precedence | undefined) =>
1774
+ right !== undefined && left.high < right.low;
1775
+
1776
+ // Port of Pco.resolve. A failure after the first item backtracks no further than its attempt.
1777
+ const parseTlapmExpression = (): Expression =>
1778
+ withRestorePoint(() => {
1779
+ const first = attempt(() => parseTlapmItem(true));
1780
+ if (first === undefined) {
1781
+ const token = peekRaw();
1782
+ throw token.kind === "End"
1783
+ ? createUnexpected("Unexpected end of expression", token)
1784
+ : createError(`required expressions(s) missing before '${getTlapmName(token)}'`, token);
1785
+ }
1786
+ return commit(() => {
1787
+ const stack = [first];
1788
+ while (true) {
1789
+ const item = attempt(() => parseTlapmItem(isTlapmOperator(stack[stack.length - 1])));
1790
+ if (item === undefined) break;
1791
+ if (isTlapmOperand(item) || item.fixity === "Prefix") {
1792
+ stack.push(item);
1793
+ continue;
1794
+ }
1795
+ while (isBelow(item, getPreviousOperator(stack))) reduceTlapmItems(stack);
1796
+ const operand = stack[stack.length - 1];
1797
+ if (item.fixity === "Postfix" && isTlapmOperand(operand)) {
1798
+ stack.splice(-1, 1, applyTlapmOperator(item, [operand]));
1799
+ continue;
1800
+ }
1801
+ const previous = getPreviousOperator(stack);
1802
+ const isLeftChain =
1803
+ previous?.fixity === "Infix" &&
1804
+ previous.isLeft &&
1805
+ item.isLeft &&
1806
+ !isBelow(previous, item);
1807
+ if (isLeftChain) reduceTlapmItems(stack);
1808
+ stack.push(item);
1809
+ }
1810
+ while (stack.length > 1) reduceTlapmItems(stack);
1811
+ const result = stack[0];
1812
+ if (!isTlapmOperand(result)) throw createError("incomplete expression");
1813
+ return result.expression;
1814
+ });
1815
+ });
1816
+
1817
+ const parseExpression = (minimumPrecedence = 0) =>
1818
+ isTlapm ? parseTlapmExpression() : parseSanyExpression(minimumPrecedence);
1819
+
1432
1820
  const parseParams = () => {
1433
1821
  if (!accept("(")) return [];
1434
1822
  const params = parseDeclarations();
@@ -1777,8 +2165,26 @@ const parse = (
1777
2165
  return defs;
1778
2166
  };
1779
2167
 
2168
+ // tlapm's usebody reads facts while an expression starts after the comma.
2169
+ const parseTlapmFacts = (): Fact[] => {
2170
+ const first = attempt(parseExpression);
2171
+ if (!first) return [];
2172
+ const facts = [first];
2173
+ withRestorePoint(() => {
2174
+ while (isAt(",")) {
2175
+ const fact = attempt(() => {
2176
+ advance();
2177
+ return parseExpression();
2178
+ });
2179
+ if (!fact) return;
2180
+ facts.push(fact);
2181
+ }
2182
+ });
2183
+ return facts;
2184
+ };
2185
+
1780
2186
  const parseFacts = () => {
1781
- const facts = isFactAhead() ? parseSeparated(parseFact) : [];
2187
+ const facts = isTlapm ? parseTlapmFacts() : isFactAhead() ? parseSeparated(parseFact) : [];
1782
2188
  const isDef = accept("DEF") || accept("DEFS");
1783
2189
  if (isTlapm && facts.length === 0 && !isDef) throw createUnexpected("Expected a fact");
1784
2190
  return { facts, defs: isDef ? parseDefs() : [] };
@@ -1858,23 +2264,50 @@ const parse = (
1858
2264
  );
1859
2265
  };
1860
2266
 
2267
+ const parseHypothesis = () => {
2268
+ if (peek().kind === "Identifier" && isAt("::", 1) && isAt("ASSUME", 2)) {
2269
+ advance();
2270
+ advance();
2271
+ }
2272
+ if (isAt("ASSUME")) return withProofScope(parseAssumeProve);
2273
+ if (peek().kind === "Keyword" && NEW_SYMBOL_STARTS.has(peek().text))
2274
+ return isTlapm ? commit(parseNewSymbol) : parseNewSymbol();
2275
+ if (!isTlapm) return parseExpression();
2276
+ // expr_or_sequent: where no expression starts, the sequent's ASSUME fails last.
2277
+ const expression = attempt(parseExpression);
2278
+ if (expression === undefined) throw createUnexpected("Expected a hypothesis");
2279
+ return expression;
2280
+ };
2281
+
2282
+ // comma1 (hyp b): Pco.star attempts the hypotheses after the first, each inside the one before,
2283
+ // so a failure that backtracks ends the list, and tlapm reports any other before the first comma.
2284
+ const parseTlapmHypotheses = () => {
2285
+ const assumptions = [parseHypothesis()];
2286
+ withRestorePoint(() => {
2287
+ while (true) {
2288
+ const assumption = attempt(() => {
2289
+ expect(",");
2290
+ return parseHypothesis();
2291
+ });
2292
+ if (assumption === undefined) break;
2293
+ assumptions.push(assumption);
2294
+ }
2295
+ });
2296
+ return assumptions;
2297
+ };
2298
+
1861
2299
  const parseAssumeProve = (): AssumeProve => {
1862
2300
  const start = cursor;
1863
2301
  const location = getLocation(expect("ASSUME"));
1864
- const assumptions = parseSeparated(() => {
1865
- if (peek().kind === "Identifier" && isAt("::", 1) && isAt("ASSUME", 2)) {
1866
- advance();
1867
- advance();
1868
- }
1869
- if (isAt("ASSUME")) return withProofScope(parseAssumeProve);
1870
- if (peek().kind === "Keyword" && NEW_SYMBOL_STARTS.has(peek().text)) return parseNewSymbol();
1871
- return parseExpression();
1872
- });
1873
- expect("PROVE");
1874
- return withRange(
1875
- { kind: "AssumeProve", assumptions, conclusion: parseExpression(), location },
1876
- start,
1877
- );
2302
+ const parseSequent = (): AssumeProve => {
2303
+ const assumptions = isTlapm ? parseTlapmHypotheses() : parseSeparated(parseHypothesis);
2304
+ expect("PROVE");
2305
+ return withRange(
2306
+ { kind: "AssumeProve", assumptions, conclusion: parseExpression(), location },
2307
+ start,
2308
+ );
2309
+ };
2310
+ return isTlapm ? commit(parseSequent) : parseSequent();
1878
2311
  };
1879
2312
 
1880
2313
  const isNameListAhead = (terminator: string) => {
@@ -1897,7 +2330,7 @@ const parse = (
1897
2330
  const parseStepBody = (): StepBody => {
1898
2331
  const token = peek();
1899
2332
  if (isAt("USE") || isAt("HIDE")) return parseUseOrHide();
1900
- if (isAt("INSTANCE")) {
2333
+ if (!isTlapm && isAt("INSTANCE")) {
1901
2334
  const start = cursor;
1902
2335
  return withRange(parseInstance(undefined, [], false, getLocation(token)), start);
1903
2336
  }
@@ -2086,20 +2519,26 @@ const parse = (
2086
2519
  throw createProofError(
2087
2520
  `Unexpected end of (sub)proof at level ${level} before QED step`,
2088
2521
  levelSpan,
2522
+ NEWLINES,
2089
2523
  );
2090
2524
  }
2091
2525
  if (item.kind === "Leaf") {
2092
2526
  throw createProofError(
2093
2527
  `Expecting a proof step but found a${LEAF_NAMES[item.proof.kind]} leaf proof`,
2094
2528
  item.span,
2529
+ NEWLINES,
2095
2530
  );
2096
2531
  }
2097
2532
  if (!isFirst && item.isProof) {
2098
- throw createProofError("PROOF keyword found in step that does not begin subproof", item.span);
2533
+ throw createProofError(
2534
+ "PROOF keyword found in step that does not begin subproof",
2535
+ item.span,
2536
+ PRINTED_NEWLINE,
2537
+ );
2099
2538
  }
2100
2539
  const implicit = item.token.text[1];
2101
2540
  if (implicit === "+" && !isFirst) {
2102
- throw createProofError("<+> used but no subproof expected", item.span);
2541
+ throw createProofError("<+> used but no subproof expected", item.span, PRINTED_NEWLINE);
2103
2542
  }
2104
2543
  const stepLevel =
2105
2544
  implicit === "*"
@@ -2154,6 +2593,7 @@ const parse = (
2154
2593
  throw createProofError(
2155
2594
  "extra step(s) after finished proof",
2156
2595
  extra.span,
2596
+ NO_NEWLINES,
2157
2597
  "Proof.Parser.toplevel",
2158
2598
  );
2159
2599
  }
@@ -2186,12 +2626,21 @@ const parse = (
2186
2626
  return name;
2187
2627
  };
2188
2628
 
2629
+ // A theorem whose statement fails to start backtracks in tlapm, whose module ends there.
2630
+ const parseTheoremExpression = () => {
2631
+ if (!isTlapm) return parseExpression();
2632
+ const token = peekRaw();
2633
+ const statement = attempt(parseExpression);
2634
+ if (statement) return statement;
2635
+ throw createUnexpected(`Expected "====" but found ${describeToken(token)}`, token);
2636
+ };
2637
+
2189
2638
  const parseTheorem = (module: Module) => {
2190
2639
  const start = cursor;
2191
2640
  const keyword = advance();
2192
2641
  const name = parseFactName();
2193
2642
  const parsed = withProofScope(() => {
2194
- const statement = isAt("ASSUME") ? parseAssumeProve() : parseExpression();
2643
+ const statement = isAt("ASSUME") ? parseAssumeProve() : parseTheoremExpression();
2195
2644
  if (isTlapm) return { statement, proof: parseTlapmProof() };
2196
2645
  return { statement, proof: isProofStart(peek()) ? parseProof() : undefined };
2197
2646
  });
@@ -2252,7 +2701,6 @@ const parse = (
2252
2701
  }
2253
2702
  while (true) {
2254
2703
  const tokenIndex = cursor;
2255
- unitStart = tokenIndex;
2256
2704
  const token = peek();
2257
2705
  if (token.kind === "ModuleEnd") {
2258
2706
  location.range = {