tla-ts 0.0.10-dev.63a6693bd → 0.0.10-dev.7a3bb1545

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