tla-ts 0.0.10-dev.f16792fed → 0.0.10-dev.fdc173479

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 (587) hide show
  1. package/README.md +2 -1
  2. package/dist/compile.cjs +6 -6
  3. package/dist/compile.js +10 -10
  4. package/dist/deciders.cjs +41 -37
  5. package/dist/deciders.js +41 -37
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +21 -4
  8. package/dist/index.d.ts +21 -4
  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 +2681 -425
  15. package/dist/prove.js +2681 -425
  16. package/dist/run.cjs +41 -42
  17. package/dist/run.js +41 -42
  18. package/dist/tlapm.cjs +2 -2
  19. package/dist/tlapm.js +2 -2
  20. package/dist/transfer.cjs +97 -89
  21. package/dist/transfer.js +97 -89
  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 +72 -39
  26. package/src/bags.ts +50 -29
  27. package/src/builtins.ts +8 -16
  28. package/src/check-failure.ts +118 -0
  29. package/src/check-trace.ts +321 -0
  30. package/src/check.ts +828 -770
  31. package/src/cli/options.ts +6 -31
  32. package/src/cli/runtime-invariants.ts +20 -56
  33. package/src/cli/shared.ts +1 -1
  34. package/src/cli/tlapm.ts +433 -70
  35. package/src/cli/tlc-arguments.ts +224 -212
  36. package/src/cli/tlc-output.ts +701 -0
  37. package/src/cli/tlc-usage.ts +1 -2
  38. package/src/cli/tlc.ts +65 -712
  39. package/src/cli/xml-exporter.ts +23 -33
  40. package/src/codegen.ts +28 -20
  41. package/src/coverage.ts +255 -20
  42. package/src/dependencies.ts +96 -27
  43. package/src/dfid.ts +115 -50
  44. package/src/environment-config.ts +315 -0
  45. package/src/environment.ts +175 -373
  46. package/src/errors.ts +40 -5
  47. package/src/evaluate.ts +429 -139
  48. package/src/exit-codes.ts +28 -12
  49. package/src/fingerprints.ts +65 -1
  50. package/src/instances.ts +178 -17
  51. package/src/java-hash.ts +14 -0
  52. package/src/java-overrides.ts +2 -2
  53. package/src/json.ts +4 -7
  54. package/src/levels.ts +708 -272
  55. package/src/lexer.ts +17 -5
  56. package/src/liveness-checker.ts +707 -249
  57. package/src/liveness.ts +148 -95
  58. package/src/obligations/action.ts +14 -17
  59. package/src/obligations/anonymize.ts +37 -16
  60. package/src/obligations/enabled-axioms.ts +218 -0
  61. package/src/obligations/equality.ts +1 -3
  62. package/src/obligations/expression.ts +36 -8
  63. package/src/obligations/format.ts +0 -2
  64. package/src/obligations/generate.ts +66 -54
  65. package/src/obligations/index.ts +39 -9
  66. package/src/obligations/levels.ts +24 -11
  67. package/src/obligations/module.ts +28 -41
  68. package/src/obligations/normalize.ts +27 -18
  69. package/src/obligations/operators.ts +0 -2
  70. package/src/obligations/pragma.ts +53 -16
  71. package/src/obligations/printer.ts +48 -18
  72. package/src/obligations/proof.ts +3 -2
  73. package/src/obligations/regroup.ts +0 -2
  74. package/src/obligations/simplify.ts +55 -50
  75. package/src/obligations/source.ts +120 -74
  76. package/src/obligations/subexpression.ts +45 -18
  77. package/src/obligations/substitution.ts +1 -3
  78. package/src/obligations/temporal.ts +5 -7
  79. package/src/obligations/tuples.ts +0 -2
  80. package/src/parallel-worker.ts +17 -31
  81. package/src/parallel.ts +29 -47
  82. package/src/parser.ts +757 -326
  83. package/src/pretty-print.ts +1 -1
  84. package/src/prover/decide-pool.ts +3 -3
  85. package/src/prover/deciders.ts +12 -9
  86. package/src/prover/isabelle/decide.ts +3 -25
  87. package/src/prover/isabelle/encode.ts +72 -42
  88. package/src/prover/isabelle/isar/attrib.ts +250 -0
  89. package/src/prover/isabelle/isar/context.ts +335 -0
  90. package/src/prover/isabelle/isar/induct.ts +382 -0
  91. package/src/prover/isabelle/isar/inner-syntax.ts +158 -7
  92. package/src/prover/isabelle/isar/method.ts +509 -212
  93. package/src/prover/isabelle/isar/proof.ts +570 -14
  94. package/src/prover/isabelle/isar/rule-cases.ts +226 -0
  95. package/src/prover/isabelle/isar/theory.ts +487 -76
  96. package/src/prover/isabelle/isar/toplevel.ts +331 -0
  97. package/src/prover/isabelle/isar/type-check.ts +89 -14
  98. package/src/prover/isabelle/provers/blast/blast.ts +7 -65
  99. package/src/prover/isabelle/provers/blast/branch.ts +0 -2
  100. package/src/prover/isabelle/provers/blast/prove.ts +0 -2
  101. package/src/prover/isabelle/provers/blast/rules.ts +0 -2
  102. package/src/prover/isabelle/provers/blast/state.ts +0 -2
  103. package/src/prover/isabelle/provers/blast/term.ts +0 -2
  104. package/src/prover/isabelle/provers/clasimp.ts +1 -3
  105. package/src/prover/isabelle/provers/classical.ts +45 -20
  106. package/src/prover/isabelle/provers/hypsubst.ts +19 -30
  107. package/src/prover/isabelle/pure/bicompose.ts +9 -27
  108. package/src/prover/isabelle/pure/consts.ts +0 -2
  109. package/src/prover/isabelle/pure/conv.ts +2 -10
  110. package/src/prover/isabelle/pure/drule.ts +72 -6
  111. package/src/prover/isabelle/pure/envir.ts +0 -2
  112. package/src/prover/isabelle/pure/goal.ts +1 -3
  113. package/src/prover/isabelle/pure/logic.ts +1 -3
  114. package/src/prover/isabelle/pure/name.ts +0 -2
  115. package/src/prover/isabelle/pure/net.ts +0 -2
  116. package/src/prover/isabelle/pure/object-logic.ts +13 -7
  117. package/src/prover/isabelle/pure/pattern.ts +0 -2
  118. package/src/prover/isabelle/pure/raw-simplifier.ts +4 -15
  119. package/src/prover/isabelle/pure/rewriter.ts +9 -20
  120. package/src/prover/isabelle/pure/search.ts +0 -2
  121. package/src/prover/isabelle/pure/seq.ts +0 -2
  122. package/src/prover/isabelle/pure/simplifier.ts +26 -7
  123. package/src/prover/isabelle/pure/table.ts +2 -3
  124. package/src/prover/isabelle/pure/tactic.ts +0 -2
  125. package/src/prover/isabelle/pure/tactical.ts +42 -37
  126. package/src/prover/isabelle/pure/term-ord.ts +0 -2
  127. package/src/prover/isabelle/pure/term.ts +3 -5
  128. package/src/prover/isabelle/pure/thm.ts +14 -13
  129. package/src/prover/isabelle/pure/type.ts +0 -2
  130. package/src/prover/isabelle/pure/unify.ts +0 -2
  131. package/src/prover/isabelle/pure/variable.ts +0 -2
  132. package/src/prover/isabelle/tla/classical-setup.ts +18 -16
  133. package/src/prover/isabelle/tla/context.ts +58 -11
  134. package/src/prover/isabelle/tla/logic-data.ts +1 -1
  135. package/src/prover/isabelle/tla/logic.ts +49 -21
  136. package/src/prover/isabelle/tla/simpdata.ts +1 -12
  137. package/src/prover/isabelle/tools/intuitionistic.ts +28 -12
  138. package/src/prover/ocaml.ts +4 -1
  139. package/src/prover/prep/action.ts +30 -31
  140. package/src/prover/prep/enabled-axioms.ts +11 -2
  141. package/src/prover/prep/fingerprint.ts +2 -5
  142. package/src/prover/prep/md5.ts +26 -29
  143. package/src/prover/prep/methods.ts +181 -51
  144. package/src/prover/prep/normalize.ts +38 -9
  145. package/src/prover/prove.ts +395 -94
  146. package/src/prover/ptl/decide.ts +95 -50
  147. package/src/prover/ptl/encode.ts +2 -3
  148. package/src/prover/ptl/tableau.ts +28 -2
  149. package/src/prover/smt/arithmetic.ts +310 -0
  150. package/src/prover/smt/axioms.ts +12 -8
  151. package/src/prover/smt/context.ts +43 -8
  152. package/src/prover/smt/data.ts +498 -379
  153. package/src/prover/smt/encode.ts +148 -57
  154. package/src/prover/smt/extensionality.ts +5 -3
  155. package/src/prover/smt/flatten.ts +4 -6
  156. package/src/prover/smt/format.ts +28 -4
  157. package/src/prover/smt/instances.ts +7 -1
  158. package/src/prover/smt/layout.ts +91 -0
  159. package/src/prover/smt/rewrite.ts +1016 -618
  160. package/src/prover/smt/simplify.ts +441 -0
  161. package/src/prover/smt/solver/ackermannize-bv-tactic.ts +62 -0
  162. package/src/prover/smt/solver/ackr-helper.ts +179 -0
  163. package/src/prover/smt/solver/ackr-model-converter.ts +105 -0
  164. package/src/prover/smt/solver/act-cache.ts +0 -1
  165. package/src/prover/smt/solver/add-bounds-tactic.ts +59 -0
  166. package/src/prover/smt/solver/aig-tactic.ts +52 -0
  167. package/src/prover/smt/solver/aig.ts +889 -0
  168. package/src/prover/smt/solver/arith-rewriter.ts +624 -9
  169. package/src/prover/smt/solver/arith-terms.ts +121 -0
  170. package/src/prover/smt/solver/array-decl-plugin.ts +175 -0
  171. package/src/prover/smt/solver/array-rewriter.ts +319 -0
  172. package/src/prover/smt/solver/asserted-formulas.ts +240 -56
  173. package/src/prover/smt/solver/ast-lt.ts +165 -11
  174. package/src/prover/smt/solver/ast-util.ts +160 -2
  175. package/src/prover/smt/solver/ast.ts +1483 -45
  176. package/src/prover/smt/solver/auf-solver.ts +25 -18
  177. package/src/prover/smt/solver/bit-blast-tactic.ts +608 -0
  178. package/src/prover/smt/solver/bit-blaster.ts +871 -0
  179. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  180. package/src/prover/smt/solver/bound-manager.ts +196 -0
  181. package/src/prover/smt/solver/bound-simplifier.ts +598 -0
  182. package/src/prover/smt/solver/bv-bound-chk.ts +492 -0
  183. package/src/prover/smt/solver/bv-decl-plugin.ts +341 -0
  184. package/src/prover/smt/solver/bv-divrem-bounds.ts +95 -0
  185. package/src/prover/smt/solver/bv-rewriter.ts +1901 -0
  186. package/src/prover/smt/solver/bv1-blast.ts +214 -0
  187. package/src/prover/smt/solver/bv2fpa-converter.ts +174 -0
  188. package/src/prover/smt/solver/bv2int-rewriter.ts +544 -0
  189. package/src/prover/smt/solver/bv2real-rewriter.ts +533 -0
  190. package/src/prover/smt/solver/card2bv.ts +127 -0
  191. package/src/prover/smt/solver/case-split-queue.ts +0 -2
  192. package/src/prover/smt/solver/cg-table.ts +39 -25
  193. package/src/prover/smt/solver/check-logic.ts +330 -0
  194. package/src/prover/smt/solver/clause.ts +0 -1
  195. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +293 -0
  196. package/src/prover/smt/solver/conflict-resolution.ts +78 -2
  197. package/src/prover/smt/solver/context.ts +598 -128
  198. package/src/prover/smt/solver/ctx-simplify.ts +29 -14
  199. package/src/prover/smt/solver/ctx-solver-simplify.ts +122 -0
  200. package/src/prover/smt/solver/datatype-decl-plugin.ts +580 -0
  201. package/src/prover/smt/solver/datatype-rewriter.ts +82 -0
  202. package/src/prover/smt/solver/demodulator.ts +786 -0
  203. package/src/prover/smt/solver/dependent-expr-state.ts +93 -0
  204. package/src/prover/smt/solver/der.ts +38 -10
  205. package/src/prover/smt/solver/diff-neq.ts +207 -0
  206. package/src/prover/smt/solver/distribute-forall.ts +57 -0
  207. package/src/prover/smt/solver/dom-simplify.ts +511 -0
  208. package/src/prover/smt/solver/dt2bv-tactic.ts +298 -0
  209. package/src/prover/smt/solver/dyn-ack.ts +0 -1
  210. package/src/prover/smt/solver/e-matching.ts +7 -8
  211. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  212. package/src/prover/smt/solver/elim-small-bv-tactic.ts +129 -0
  213. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  214. package/src/prover/smt/solver/elim-uncnstr.ts +548 -0
  215. package/src/prover/smt/solver/enode.ts +100 -3
  216. package/src/prover/smt/solver/eq2bv-tactic.ts +227 -0
  217. package/src/prover/smt/solver/euf/arith-axioms.ts +403 -0
  218. package/src/prover/smt/solver/euf/arith-internalize.ts +653 -0
  219. package/src/prover/smt/solver/euf/arith-solver.ts +889 -0
  220. package/src/prover/smt/solver/euf/array-axioms.ts +527 -0
  221. package/src/prover/smt/solver/euf/array-internalize.ts +428 -0
  222. package/src/prover/smt/solver/euf/array-solver.ts +306 -0
  223. package/src/prover/smt/solver/euf/bv-ackerman.ts +162 -0
  224. package/src/prover/smt/solver/euf/bv-internalize.ts +748 -0
  225. package/src/prover/smt/solver/euf/bv-solver.ts +449 -0
  226. package/src/prover/smt/solver/euf/dt-solver.ts +618 -0
  227. package/src/prover/smt/solver/euf/egraph.ts +901 -0
  228. package/src/prover/smt/solver/euf/euf-solver.ts +1204 -0
  229. package/src/prover/smt/solver/euf/fpa-solver.ts +317 -0
  230. package/src/prover/smt/solver/euf/mam.ts +1046 -0
  231. package/src/prover/smt/solver/euf/q-ematch.ts +829 -0
  232. package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
  233. package/src/prover/smt/solver/euf/q-model-fixer.ts +296 -0
  234. package/src/prover/smt/solver/euf/q-solver.ts +361 -0
  235. package/src/prover/smt/solver/euf/th-solver.ts +328 -0
  236. package/src/prover/smt/solver/euf/th-solvers.ts +30 -0
  237. package/src/prover/smt/solver/expr-ref.ts +0 -1
  238. package/src/prover/smt/solver/expr-safe-replace.ts +26 -2
  239. package/src/prover/smt/solver/expr2polynomial.ts +271 -0
  240. package/src/prover/smt/solver/factor.ts +163 -0
  241. package/src/prover/smt/solver/fd-solver.ts +734 -0
  242. package/src/prover/smt/solver/fingerprints.ts +15 -15
  243. package/src/prover/smt/solver/fix-dl-var.ts +147 -0
  244. package/src/prover/smt/solver/flat-literals.ts +0 -1
  245. package/src/prover/smt/solver/fm-tactic.ts +886 -0
  246. package/src/prover/smt/solver/fpa-decl-plugin.ts +618 -0
  247. package/src/prover/smt/solver/fpa-rewriter.ts +639 -0
  248. package/src/prover/smt/solver/fpa2bv-converter.ts +2251 -0
  249. package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
  250. package/src/prover/smt/solver/fpa2bv-tactic.ts +73 -0
  251. package/src/prover/smt/solver/goal.ts +178 -15
  252. package/src/prover/smt/solver/goal2nlsat.ts +216 -0
  253. package/src/prover/smt/solver/guard-set.ts +219 -0
  254. package/src/prover/smt/solver/hash.ts +0 -1
  255. package/src/prover/smt/solver/hashtable.ts +34 -16
  256. package/src/prover/smt/solver/inf-eps.ts +63 -0
  257. package/src/prover/smt/solver/inj-axiom.ts +101 -0
  258. package/src/prover/smt/solver/internalizer.ts +111 -39
  259. package/src/prover/smt/solver/lackr.ts +381 -0
  260. package/src/prover/smt/solver/lbool.ts +0 -1
  261. package/src/prover/smt/solver/lia2card.ts +268 -0
  262. package/src/prover/smt/solver/lia2pb.ts +154 -0
  263. package/src/prover/smt/solver/literal.ts +0 -1
  264. package/src/prover/smt/solver/logic-tactics.ts +355 -0
  265. package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
  266. package/src/prover/smt/solver/lp/constraints.ts +0 -1
  267. package/src/prover/smt/solver/lp/containers.ts +7 -2
  268. package/src/prover/smt/solver/lp/core-solver.ts +30 -11
  269. package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
  270. package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
  271. package/src/prover/smt/solver/lp/dependency.ts +0 -2
  272. package/src/prover/smt/solver/lp/dioph-eq.ts +1 -10
  273. package/src/prover/smt/solver/lp/explanation.ts +0 -1
  274. package/src/prover/smt/solver/lp/gomory.ts +0 -1
  275. package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -2
  276. package/src/prover/smt/solver/lp/hnf.ts +0 -3
  277. package/src/prover/smt/solver/lp/int-cube.ts +3 -4
  278. package/src/prover/smt/solver/lp/int-solver.ts +0 -2
  279. package/src/prover/smt/solver/lp/lar-solver.ts +41 -5
  280. package/src/prover/smt/solver/lp/lar-term.ts +0 -1
  281. package/src/prover/smt/solver/lp/lp-settings.ts +6 -3
  282. package/src/prover/smt/solver/lp/maximize-term.ts +59 -10
  283. package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
  284. package/src/prover/smt/solver/lp/nex.ts +2 -2
  285. package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
  286. package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
  287. package/src/prover/smt/solver/lp/nla-core.ts +68 -17
  288. package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
  289. package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
  290. package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
  291. package/src/prover/smt/solver/lp/nla-grobner.ts +167 -85
  292. package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
  293. package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
  294. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
  295. package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
  296. package/src/prover/smt/solver/lp/nla-order.ts +0 -2
  297. package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
  298. package/src/prover/smt/solver/lp/nla-powers.ts +220 -0
  299. package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
  300. package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
  301. package/src/prover/smt/solver/lp/nla-transcendentals.ts +324 -0
  302. package/src/prover/smt/solver/lp/nla-types.ts +0 -2
  303. package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
  304. package/src/prover/smt/solver/lp/nra-solver.ts +163 -99
  305. package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
  306. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
  307. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
  308. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
  309. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  310. package/src/prover/smt/solver/lp/random-updater.ts +0 -2
  311. package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
  312. package/src/prover/smt/solver/lp/union-find.ts +7 -2
  313. package/src/prover/smt/solver/macro-finder.ts +530 -0
  314. package/src/prover/smt/solver/mam-compiler.ts +122 -90
  315. package/src/prover/smt/solver/mam-interpreter.ts +0 -1
  316. package/src/prover/smt/solver/max-bv-sharing-tactic.ts +17 -0
  317. package/src/prover/smt/solver/max-cliques.ts +105 -0
  318. package/src/prover/smt/solver/maxcore.ts +310 -0
  319. package/src/prover/smt/solver/maximize-ac-sharing.ts +8 -6
  320. package/src/prover/smt/solver/maxlex.ts +115 -0
  321. package/src/prover/smt/solver/maxsmt-base.ts +106 -0
  322. package/src/prover/smt/solver/maxsmt.ts +92 -0
  323. package/src/prover/smt/solver/mbp/mbp-arith.ts +467 -0
  324. package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +101 -0
  325. package/src/prover/smt/solver/mbp/mbp-plugin.ts +287 -0
  326. package/src/prover/smt/solver/mbp/mbp-qel.ts +48 -0
  327. package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +271 -0
  328. package/src/prover/smt/solver/mbp/mbp-term-graph.ts +606 -0
  329. package/src/prover/smt/solver/model-based-opt.ts +844 -0
  330. package/src/prover/smt/solver/model-checker.ts +19 -28
  331. package/src/prover/smt/solver/model-evaluator.ts +190 -12
  332. package/src/prover/smt/solver/model-finder.ts +12 -18
  333. package/src/prover/smt/solver/model-generator.ts +104 -35
  334. package/src/prover/smt/solver/model-macro-solver.ts +49 -46
  335. package/src/prover/smt/solver/model-printer.ts +214 -0
  336. package/src/prover/smt/solver/mpf.ts +709 -0
  337. package/src/prover/smt/solver/mus.ts +50 -0
  338. package/src/prover/smt/solver/muz/dl-context.ts +382 -0
  339. package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +97 -0
  340. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +167 -0
  341. package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +125 -0
  342. package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +299 -0
  343. package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +455 -0
  344. package/src/prover/smt/solver/muz/dl-mk-slice.ts +340 -0
  345. package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +163 -0
  346. package/src/prover/smt/solver/muz/dl-rule-set.ts +273 -0
  347. package/src/prover/smt/solver/muz/dl-rule-transformer.ts +123 -0
  348. package/src/prover/smt/solver/muz/dl-rule.ts +495 -0
  349. package/src/prover/smt/solver/muz/hnf.ts +201 -0
  350. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
  351. package/src/prover/smt/solver/muz/horn-tactic.ts +214 -0
  352. package/src/prover/smt/solver/muz/rule-properties.ts +359 -0
  353. package/src/prover/smt/solver/muz/spacer-context.ts +1404 -0
  354. package/src/prover/smt/solver/muz/spacer-dl-interface.ts +52 -0
  355. package/src/prover/smt/solver/muz/spacer-generalizers.ts +241 -0
  356. package/src/prover/smt/solver/muz/spacer-manager.ts +127 -0
  357. package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
  358. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +333 -0
  359. package/src/prover/smt/solver/muz/spacer-util.ts +282 -0
  360. package/src/prover/smt/solver/muz/substitution.ts +203 -0
  361. package/src/prover/smt/solver/nla2bv-tactic.ts +285 -0
  362. package/src/prover/smt/solver/nlqsat.ts +485 -0
  363. package/src/prover/smt/solver/nlsat/algebraic.ts +315 -98
  364. package/src/prover/smt/solver/nlsat/atoms.ts +71 -38
  365. package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
  366. package/src/prover/smt/solver/nlsat/explain.ts +427 -229
  367. package/src/prover/smt/solver/nlsat/interval-set.ts +1 -2
  368. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -246
  369. package/src/prover/smt/solver/nlsat/mpbq.ts +45 -1
  370. package/src/prover/smt/solver/nlsat/polynomial.ts +2376 -684
  371. package/src/prover/smt/solver/nlsat/solver.ts +293 -92
  372. package/src/prover/smt/solver/nlsat/transcendental-eval.ts +310 -0
  373. package/src/prover/smt/solver/nlsat/transcendentals.ts +391 -0
  374. package/src/prover/smt/solver/nlsat/types.ts +0 -2
  375. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +9 -8
  376. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
  377. package/src/prover/smt/solver/nlsat-tactic.ts +82 -0
  378. package/src/prover/smt/solver/nnf.ts +110 -24
  379. package/src/prover/smt/solver/normalize-bounds.ts +53 -0
  380. package/src/prover/smt/solver/occf.ts +97 -0
  381. package/src/prover/smt/solver/opt-context.ts +801 -0
  382. package/src/prover/smt/solver/opt-nlsat.ts +386 -0
  383. package/src/prover/smt/solver/opt-pareto.ts +301 -0
  384. package/src/prover/smt/solver/opt-preprocess.ts +101 -0
  385. package/src/prover/smt/solver/opt-solver.ts +312 -0
  386. package/src/prover/smt/solver/opt-value.ts +55 -0
  387. package/src/prover/smt/solver/optsmt.ts +692 -0
  388. package/src/prover/smt/solver/parallel-tactic.ts +299 -0
  389. package/src/prover/smt/solver/pattern-inference.ts +19 -11
  390. package/src/prover/smt/solver/pb-rewriter.ts +281 -0
  391. package/src/prover/smt/solver/pb2bv-tactic.ts +546 -0
  392. package/src/prover/smt/solver/poly-rewriter.ts +259 -57
  393. package/src/prover/smt/solver/probes.ts +577 -0
  394. package/src/prover/smt/solver/propagate-values.ts +37 -21
  395. package/src/prover/smt/solver/proto-model.ts +648 -19
  396. package/src/prover/smt/solver/pull-quant.ts +28 -12
  397. package/src/prover/smt/solver/purify-arith.ts +634 -0
  398. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  399. package/src/prover/smt/solver/qe-arith-plugin.ts +1096 -0
  400. package/src/prover/smt/solver/qe-lite-der.ts +2 -3
  401. package/src/prover/smt/solver/qe-lite-fm.ts +3 -4
  402. package/src/prover/smt/solver/qe-lite.ts +39 -19
  403. package/src/prover/smt/solver/qe-mbp.ts +270 -0
  404. package/src/prover/smt/solver/qe.ts +1499 -0
  405. package/src/prover/smt/solver/qel.ts +25 -0
  406. package/src/prover/smt/solver/qi-queue.ts +0 -1
  407. package/src/prover/smt/solver/qsat.ts +829 -0
  408. package/src/prover/smt/solver/quant-hoist.ts +196 -0
  409. package/src/prover/smt/solver/quant-tactics.ts +16 -56
  410. package/src/prover/smt/solver/quantifier-analyzer.ts +19 -20
  411. package/src/prover/smt/solver/quantifier-manager.ts +22 -25
  412. package/src/prover/smt/solver/quasi-macros.ts +243 -0
  413. package/src/prover/smt/solver/random-gen.ts +0 -1
  414. package/src/prover/smt/solver/rational.ts +45 -1
  415. package/src/prover/smt/solver/recfun-decl-plugin.ts +262 -0
  416. package/src/prover/smt/solver/recfun-rewriter.ts +107 -0
  417. package/src/prover/smt/solver/reduce-args.ts +225 -0
  418. package/src/prover/smt/solver/reduce-bv-size.ts +119 -0
  419. package/src/prover/smt/solver/ref-vector.ts +0 -1
  420. package/src/prover/smt/solver/relevancy.ts +1 -2
  421. package/src/prover/smt/solver/rewriter-tpl.ts +82 -14
  422. package/src/prover/smt/solver/rewriter.ts +505 -60
  423. package/src/prover/smt/solver/rlimit.ts +45 -5
  424. package/src/prover/smt/solver/sat/asymm-branch.ts +325 -0
  425. package/src/prover/smt/solver/sat/big.ts +177 -0
  426. package/src/prover/smt/solver/sat/clause-use-list.ts +71 -0
  427. package/src/prover/smt/solver/sat/clause.ts +203 -0
  428. package/src/prover/smt/solver/sat/cleaner.ts +94 -0
  429. package/src/prover/smt/solver/sat/config.ts +122 -0
  430. package/src/prover/smt/solver/sat/consequences.ts +203 -0
  431. package/src/prover/smt/solver/sat/elim-eqs.ts +142 -0
  432. package/src/prover/smt/solver/sat/goal2sat.ts +589 -0
  433. package/src/prover/smt/solver/sat/inc-sat-solver.ts +480 -0
  434. package/src/prover/smt/solver/sat/model-converter.ts +136 -0
  435. package/src/prover/smt/solver/sat/pb-constraint.ts +268 -0
  436. package/src/prover/smt/solver/sat/pb-solver.ts +1596 -0
  437. package/src/prover/smt/solver/sat/probing.ts +170 -0
  438. package/src/prover/smt/solver/sat/sat-tactic.ts +72 -0
  439. package/src/prover/smt/solver/sat/sat2goal.ts +190 -0
  440. package/src/prover/smt/solver/sat/scc.ts +142 -0
  441. package/src/prover/smt/solver/sat/simplifier.ts +1618 -0
  442. package/src/prover/smt/solver/sat/solver.ts +2107 -0
  443. package/src/prover/smt/solver/sat/var-queue.ts +117 -0
  444. package/src/prover/smt/solver/sat/watch-list.ts +140 -0
  445. package/src/prover/smt/solver/search-tree.ts +284 -0
  446. package/src/prover/smt/solver/seq-axioms.ts +995 -0
  447. package/src/prover/smt/solver/seq-decl-plugin.ts +819 -0
  448. package/src/prover/smt/solver/seq-derive.ts +1298 -0
  449. package/src/prover/smt/solver/seq-eq-approx.ts +236 -0
  450. package/src/prover/smt/solver/seq-eq-solver.ts +439 -0
  451. package/src/prover/smt/solver/seq-factory.ts +89 -0
  452. package/src/prover/smt/solver/seq-monadic.ts +730 -0
  453. package/src/prover/smt/solver/seq-range-predicate.ts +235 -0
  454. package/src/prover/smt/solver/seq-re-rewriter.ts +1171 -0
  455. package/src/prover/smt/solver/seq-re-util.ts +758 -0
  456. package/src/prover/smt/solver/seq-regex-bisim.ts +144 -0
  457. package/src/prover/smt/solver/seq-regex-live.ts +200 -0
  458. package/src/prover/smt/solver/seq-rewriter.ts +2404 -0
  459. package/src/prover/smt/solver/seq-skolem.ts +294 -0
  460. package/src/prover/smt/solver/seq-subset.ts +165 -0
  461. package/src/prover/smt/solver/seq-view-witness.ts +353 -0
  462. package/src/prover/smt/solver/smt-consequences.ts +297 -0
  463. package/src/prover/smt/solver/smt-kernel.ts +124 -0
  464. package/src/prover/smt/solver/smt-logics.ts +66 -0
  465. package/src/prover/smt/solver/smt-setup.ts +589 -0
  466. package/src/prover/smt/solver/smt2-printer.ts +765 -0
  467. package/src/prover/smt/solver/smtlib-parser.ts +3535 -360
  468. package/src/prover/smt/solver/smtlib-script.ts +2136 -0
  469. package/src/prover/smt/solver/solve-eqs.ts +928 -0
  470. package/src/prover/smt/solver/solver.ts +128 -23
  471. package/src/prover/smt/solver/static-features.ts +314 -0
  472. package/src/prover/smt/solver/sticky-generations.ts +0 -1
  473. package/src/prover/smt/solver/tactic.ts +2176 -0
  474. package/src/prover/smt/solver/term-enumeration.ts +205 -0
  475. package/src/prover/smt/solver/theory-array.ts +1240 -0
  476. package/src/prover/smt/solver/theory-bv.ts +1210 -0
  477. package/src/prover/smt/solver/theory-char.ts +355 -0
  478. package/src/prover/smt/solver/theory-datatype.ts +598 -0
  479. package/src/prover/smt/solver/theory-finite-set.ts +30 -0
  480. package/src/prover/smt/solver/theory-fpa.ts +389 -0
  481. package/src/prover/smt/solver/theory-lra-axioms.ts +53 -2
  482. package/src/prover/smt/solver/theory-lra-bounds.ts +31 -6
  483. package/src/prover/smt/solver/theory-lra-final-check.ts +57 -70
  484. package/src/prover/smt/solver/theory-lra-internalize.ts +96 -27
  485. package/src/prover/smt/solver/theory-lra-model.ts +20 -35
  486. package/src/prover/smt/solver/theory-lra-propagate.ts +35 -28
  487. package/src/prover/smt/solver/theory-lra-state.ts +7 -23
  488. package/src/prover/smt/solver/theory-lra.ts +189 -2
  489. package/src/prover/smt/solver/theory-pb.ts +951 -0
  490. package/src/prover/smt/solver/theory-polymorphism.ts +58 -0
  491. package/src/prover/smt/solver/theory-recfun.ts +307 -0
  492. package/src/prover/smt/solver/theory-seq-regex.ts +867 -0
  493. package/src/prover/smt/solver/theory-seq-solve.ts +1373 -0
  494. package/src/prover/smt/solver/theory-seq-state.ts +852 -0
  495. package/src/prover/smt/solver/theory-seq.ts +961 -0
  496. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  497. package/src/prover/smt/solver/theory.ts +189 -0
  498. package/src/prover/smt/solver/tseitin-cnf.ts +495 -0
  499. package/src/prover/smt/solver/var-subst.ts +36 -14
  500. package/src/prover/smt/table.ts +3 -2
  501. package/src/prover/smt/types.ts +146 -0
  502. package/src/prover/tlapm/cache.ts +57 -26
  503. package/src/prover/tlapm/tlapm.ts +15 -9
  504. package/src/prover/tlapm-library.ts +3208 -0
  505. package/src/prover/verdict.ts +9 -0
  506. package/src/prover/zenon/check/check.ts +1 -2
  507. package/src/prover/zenon/check/records.ts +1 -1
  508. package/src/prover/zenon/check/relations.ts +2 -1
  509. package/src/prover/zenon/check/rewrites.ts +2 -15
  510. package/src/prover/zenon/check/sets.ts +40 -58
  511. package/src/prover/zenon/check/terms.ts +1 -2
  512. package/src/prover/zenon/decide.ts +10 -7
  513. package/src/prover/zenon/encode.ts +0 -2
  514. package/src/prover/zenon/eqrel.ts +2 -2
  515. package/src/prover/zenon/equality-rules.ts +24 -2
  516. package/src/prover/zenon/expr.ts +28 -2
  517. package/src/prover/zenon/index-table.ts +16 -23
  518. package/src/prover/zenon/isar-case.ts +1 -3
  519. package/src/prover/zenon/isar.ts +37 -39
  520. package/src/prover/zenon/llproof.ts +2 -13
  521. package/src/prover/zenon/mltoll.ts +12 -30
  522. package/src/prover/zenon/node.ts +20 -5
  523. package/src/prover/zenon/parse.ts +9 -8
  524. package/src/prover/zenon/phrase.ts +1 -3
  525. package/src/prover/zenon/proof.ts +0 -2
  526. package/src/prover/zenon/propositional-rules.ts +0 -2
  527. package/src/prover/zenon/rules.ts +2 -3
  528. package/src/prover/zenon/search.ts +11 -19
  529. package/src/prover/zenon/tla/functions.ts +2 -4
  530. package/src/prover/zenon/tla/llproof.ts +9 -13
  531. package/src/prover/zenon/tla/records.ts +1 -8
  532. package/src/prover/zenon/tla/rewrites.ts +0 -2
  533. package/src/prover/zenon/tla/sets.ts +22 -22
  534. package/src/prover/zenon/tla/terms.ts +0 -2
  535. package/src/prover/zenon/tla/tla.ts +7 -8
  536. package/src/resolve.ts +1327 -328
  537. package/src/runtime.ts +25 -2
  538. package/src/sany/builtins.ts +10 -10
  539. package/src/sany/generation.ts +384 -0
  540. package/src/sany/generator-def-entries.ts +297 -0
  541. package/src/sany/generator-definitions.ts +688 -0
  542. package/src/sany/generator-expressions.ts +1123 -0
  543. package/src/sany/generator-proofs.ts +668 -0
  544. package/src/sany/generator.ts +161 -2625
  545. package/src/sany/levels.ts +0 -2
  546. package/src/sany/lexer.ts +32 -23
  547. package/src/sany/linter.ts +0 -2
  548. package/src/sany/modules.ts +4 -2
  549. package/src/sany/nodes.ts +3 -4
  550. package/src/sany/report.ts +3 -6
  551. package/src/sany/selectors.ts +46 -44
  552. package/src/sany/xml.ts +25 -58
  553. package/src/search.ts +513 -165
  554. package/src/simulate.ts +340 -251
  555. package/src/spec-description.ts +48 -55
  556. package/src/standard-definitions.ts +5 -0
  557. package/src/standard-modules.ts +72 -54
  558. package/src/state-graph.ts +0 -2
  559. package/src/subexpressions.ts +564 -138
  560. package/src/substitution-levels.ts +5 -4
  561. package/src/successors.ts +56 -28
  562. package/src/symmetry.ts +4 -3
  563. package/src/tableau.ts +2 -2
  564. package/src/tlc/fingerprint.ts +81 -9
  565. package/src/tlc/jar-data.ts +10 -0
  566. package/src/tlc/messages.ts +23 -18
  567. package/src/tlc/order.ts +14 -3
  568. package/src/tlc/random.ts +6 -5
  569. package/src/tlc/replay.ts +152 -58
  570. package/src/tlc/summary.ts +29 -14
  571. package/src/tlc/tlc-operators.ts +12 -11
  572. package/src/tlc/tlcext-operators.ts +87 -26
  573. package/src/tlc/trace-spec.ts +27 -60
  574. package/src/trace-liveness.ts +529 -0
  575. package/src/typed-tier.ts +6556 -0
  576. package/src/typescript/actions.ts +2 -4
  577. package/src/typescript/collections.ts +34 -20
  578. package/src/typescript/compile.ts +1 -3
  579. package/src/typescript/formula.ts +5 -3
  580. package/src/typescript/model.ts +4 -5
  581. package/src/typescript/steps.ts +20 -18
  582. package/src/typescript/types.ts +2 -2
  583. package/src/values.ts +208 -227
  584. package/src/prover/isabelle/isar/statement.ts +0 -52
  585. package/src/prover/smt/solver/z3-license.txt +0 -10
  586. package/src/prover/tlaps-module.ts +0 -510
  587. package/src/prover/zenon/LICENSE +0 -32
package/src/levels.ts CHANGED
@@ -1,27 +1,30 @@
1
1
  import {
2
2
  getChildren,
3
3
  type AssumeProve,
4
+ type Bound,
4
5
  type Definition,
5
6
  type Expression,
7
+ type Fact,
8
+ type LetExpression,
6
9
  type Module,
10
+ type ModuleUnit,
11
+ type NewSymbol,
7
12
  type OperatorParam,
8
13
  type Proof,
9
14
  type ProofStep,
10
15
  type SourceLocation,
16
+ type SourceRange,
11
17
  } from "./ast";
12
- import {
13
- createSanyError,
14
- createSemanticError,
15
- formatRange,
16
- TlaSyntaxError,
17
- type SanyError,
18
- } from "./errors";
19
- import { mapChildren } from "./instances";
20
- import { collectSemanticErrors, getBoundNames, getPatternNames } from "./resolve";
18
+ import { formatRange, type SanyError } from "./errors";
19
+ import { forEachChild } from "./instances";
20
+ import { parenthesizedRanges } from "./parser";
21
+ import { collectSemanticErrors, getBoundNames, getPatternNames, isBefore } from "./resolve";
22
+ import { resolveSynonym } from "./tlc/jar-data";
21
23
  import { STANDARD_LEVELS } from "./standard-definitions";
22
24
 
23
25
  interface LevelData {
24
26
  level: number;
27
+ isCorrect: boolean;
25
28
  params: Set<string>;
26
29
  constraints: Map<string, number>;
27
30
  argConstraints: Map<string, number>;
@@ -46,7 +49,7 @@ interface LevelContext {
46
49
  }
47
50
 
48
51
  type ScopeEntry =
49
- | { kind: "Formal"; arity: number }
52
+ | { kind: "Formal"; arity: number; level: number }
50
53
  | { kind: "Let"; definition: Definition; scope: Scope };
51
54
 
52
55
  export type Scope = Map<string, ScopeEntry>;
@@ -55,17 +58,37 @@ type Resolved =
55
58
  | { kind: "Declared"; name: string; level: number; arity: number }
56
59
  | { kind: "Defined"; levels: OperatorLevels };
57
60
 
58
- interface Operand {
59
- data: LevelData;
60
- operator?: OperatorLevels;
61
- declared?: OperatorParam;
61
+ interface SectionMember {
62
+ definition: Definition;
63
+ scope: Scope;
64
+ isRechecked: boolean;
65
+ }
66
+
67
+ interface RecursiveSection {
68
+ location: SourceLocation;
69
+ members: SectionMember[];
62
70
  }
63
71
 
72
+ type ScopeFrame = Definition | LetExpression | string[];
73
+
74
+ type Operand =
75
+ | { kind: "Value"; data: LevelData }
76
+ | { kind: "Operator"; data: OperatorLevels }
77
+ | { kind: "Declared"; data: LevelData; declared: OperatorParam };
78
+
64
79
  export const CONSTANT_LEVEL = 0;
65
80
  export const VARIABLE_LEVEL = 1;
66
81
  export const ACTION_LEVEL = 2;
67
82
  export const TEMPORAL_LEVEL = 3;
68
83
 
84
+ const NEW_SYMBOL_LEVELS = {
85
+ Constant: CONSTANT_LEVEL,
86
+ Variable: VARIABLE_LEVEL,
87
+ State: VARIABLE_LEVEL,
88
+ Action: ACTION_LEVEL,
89
+ Temporal: TEMPORAL_LEVEL,
90
+ } satisfies Record<NewSymbol["level"], number>;
91
+
69
92
  const SEPARATOR = "\u0000";
70
93
 
71
94
  export const getArgumentKey = (operator: string, index: number) =>
@@ -84,6 +107,7 @@ const getConditionKey = (operator: number, operand: number, argument: number) =>
84
107
 
85
108
  const createData = (level = 0): LevelData => ({
86
109
  level,
110
+ isCorrect: true,
87
111
  params: new Set(),
88
112
  constraints: new Map(),
89
113
  argConstraints: new Map(),
@@ -96,6 +120,12 @@ export const putConstraint = (constraints: Map<string, number>, name: string, le
96
120
  export const putArgConstraint = (constraints: Map<string, number>, key: string, level: number) =>
97
121
  constraints.set(key, Math.max(level, constraints.get(key) ?? 0));
98
122
 
123
+ const mergeConstraints = (data: LevelData, part: LevelData) => {
124
+ part.constraints.forEach((value, key) => putConstraint(data.constraints, key, value));
125
+ part.argConstraints.forEach((value, key) => putArgConstraint(data.argConstraints, key, value));
126
+ part.argParams.forEach((key) => data.argParams.add(key));
127
+ };
128
+
99
129
  const createSignature = (
100
130
  name: string,
101
131
  level: number,
@@ -149,27 +179,50 @@ const CORE_SIGNATURES = new Map(
149
179
  ["BOOLEAN", 0, [], []],
150
180
  ["STRING", 0, [], []],
151
181
  ] as const
152
- ).map(([name, level, maxLevels, weights]): [string, OperatorLevels] => [
153
- name,
182
+ ).map((signature): [string, OperatorLevels] => [
183
+ signature[0],
154
184
  {
155
- ...createSignature(name, level, [...maxLevels], [...weights]),
156
- nonLeibniz: new Set(level > 1 ? [0, 1] : []),
185
+ ...createSignature(signature[0], signature[1], [...signature[2]], [...signature[3]]),
186
+ nonLeibniz: new Set(signature[1] > 1 ? [0, 1] : []),
157
187
  },
158
188
  ]),
159
189
  );
160
190
 
161
- const SET_LEVELS = createSignature("$Set", 0, [2], [1]);
162
- const JUNCTION_LEVELS = createSignature("$Junction", 0, [3], [1]);
163
- const CHOOSE_LEVELS = createSignature("$Choose", 0, [2], [1]);
164
- const FUNCTION_LEVELS = createSignature("$Function", 0, [3], [1]);
165
- const APPLY_LEVELS = createSignature("$FcnApply", 0, [2, 2], [1, 1]);
166
- const SELECT_LEVELS = createSignature("$RcdSelect", 0, [2, 0], [1, 1]);
167
191
  const PRIME_LEVELS = createSignature("'", 2, [1], [0]);
192
+ const UNCHANGED_LEVELS = createSignature("UNCHANGED", 2, [1], [0]);
168
193
  const ENABLED_LEVELS = createSignature("ENABLED", 1, [2], [0]);
169
- const TEMPORAL_LEVELS = createSignature("[]", 3, [3], [0]);
170
- const ACTION_LEVELS = createSignature("$SquareAct", 2, [2, 1], [0, 0]);
171
- const FAIRNESS_LEVELS = createSignature("$WF", 3, [1, 2], [0, 0]);
172
- const TEMPORAL_QUANTIFIER_LEVELS = createSignature("$TemporalExists", 3, [3], [0]);
194
+ const ALWAYS_LEVELS = createSignature("[]", 3, [3], [0]);
195
+ const EVENTUALLY_LEVELS = createSignature("<>", 3, [3], [0]);
196
+ const AND_LEVELS = createSignature("$ConjList", 0, [3], [1]);
197
+ const OR_LEVELS = createSignature("$DisjList", 0, [3], [1]);
198
+ const IF_LEVELS = createSignature("$IfThenElse", 0, [3], [1]);
199
+ const CASE_LEVELS = createSignature("$Case", 0, [3], [1]);
200
+ const FORALL_LEVELS = createSignature("$BoundedForall", 0, [3], [1]);
201
+ const EXISTS_LEVELS = createSignature("$BoundedExists", 0, [3], [1]);
202
+ const UNBOUNDED_FORALL_LEVELS = createSignature("$UnboundedForall", 0, [3], [1]);
203
+ const UNBOUNDED_EXISTS_LEVELS = createSignature("$UnboundedExists", 0, [3], [1]);
204
+ const TEMPORAL_FORALL_LEVELS = createSignature("$TemporalForall", 3, [3], [0]);
205
+ const TEMPORAL_EXISTS_LEVELS = createSignature("$TemporalExists", 3, [3], [0]);
206
+ const BOUNDED_CHOOSE_LEVELS = createSignature("$BoundedChoose", 0, [2], [1]);
207
+ const UNBOUNDED_CHOOSE_LEVELS = createSignature("$UnboundedChoose", 0, [2], [1]);
208
+ const SET_ENUMERATE_LEVELS = createSignature("$SetEnumerate", 0, [2], [1]);
209
+ const TUPLE_LEVELS = createSignature("$Tuple", 0, [2], [1]);
210
+ const SET_OF_FCNS_LEVELS = createSignature("$SetOfFcns", 0, [2], [1]);
211
+ const CARTESIAN_PROD_LEVELS = createSignature("$CartesianProd", 0, [2], [1]);
212
+ const SUBSET_OF_LEVELS = createSignature("$SubsetOf", 0, [2], [1]);
213
+ const SET_OF_ALL_LEVELS = createSignature("$SetOfAll", 0, [2], [1]);
214
+ const FCN_CONSTRUCTOR_LEVELS = createSignature("$FcnConstructor", 0, [3], [1]);
215
+ const RCD_CONSTRUCTOR_LEVELS = createSignature("$RcdConstructor", 0, [3], [1]);
216
+ const SET_OF_RCDS_LEVELS = createSignature("$SetOfRcds", 0, [2], [1]);
217
+ const EXCEPT_LEVELS = createSignature("$Except", 0, [2], [1]);
218
+ const PAIR_LEVELS = createSignature("$Pair", 0, [3], [1]);
219
+ const SEQ_LEVELS = createSignature("$Seq", 0, [2], [1]);
220
+ const APPLY_LEVELS = createSignature("$FcnApply", 0, [2, 2], [1, 1]);
221
+ const SELECT_LEVELS = createSignature("$RcdSelect", 0, [2, 0], [1, 1]);
222
+ const SQUARE_ACT_LEVELS = createSignature("$SquareAct", 2, [2, 1], [0, 0]);
223
+ const ANGLE_ACT_LEVELS = createSignature("$AngleAct", 2, [2, 1], [0, 0]);
224
+ const WF_LEVELS = createSignature("$WF", 3, [1, 2], [0, 0]);
225
+ const SF_LEVELS = createSignature("$SF", 3, [1, 2], [0, 0]);
173
226
 
174
227
  const bindFormals = (scope: Scope, formals: OperatorParam[]) =>
175
228
  formals.length === 0
@@ -178,31 +231,204 @@ const bindFormals = (scope: Scope, formals: OperatorParam[]) =>
178
231
  ...scope,
179
232
  ...formals.map((formal): [string, ScopeEntry] => [
180
233
  formal.name,
181
- { kind: "Formal", arity: formal.arity },
234
+ { kind: "Formal", arity: formal.arity, level: CONSTANT_LEVEL },
182
235
  ]),
183
236
  ]);
184
237
 
185
238
  const toFormals = (names: string[]) => names.map((name) => ({ name, arity: 0 }));
186
239
 
187
- const createLevelError = (message: string, expression: Expression) =>
188
- expression.location.range
189
- ? createSemanticError(`${message}.`, expression.location.range)
190
- : new TlaSyntaxError(
191
- `${message} at line ${expression.location.line}, column ${expression.location.column}`,
192
- );
240
+ const getFormals = (definition: Definition) =>
241
+ definition.kind === "Operator" ? definition.params : [];
242
+
243
+ const getDefinitionBody = (definition: Definition): Expression =>
244
+ definition.kind === "Function"
245
+ ? {
246
+ kind: "FunctionConstruction",
247
+ bounds: definition.bounds,
248
+ body: definition.body,
249
+ location: definition.location,
250
+ }
251
+ : definition.body;
252
+
253
+ const createLetScope = (expression: LetExpression, scope: Scope) => {
254
+ const inner: Scope = new Map(scope);
255
+ expression.definitions.forEach((definition) =>
256
+ inner.set(definition.name, { kind: "Let", definition, scope: inner }),
257
+ );
258
+ return inner;
259
+ };
260
+
261
+ const createPlaceholder = (definition: Definition, maxLevel: number, weight: number) => {
262
+ const formals = getFormals(definition);
263
+ return {
264
+ ...createData(),
265
+ name: definition.name,
266
+ formals,
267
+ maxLevels: formals.map(() => maxLevel),
268
+ weights: formals.map(() => weight),
269
+ minMaxLevels: formals.map(() => []),
270
+ conditions: new Set<string>(),
271
+ nonLeibniz: new Set<number>(),
272
+ };
273
+ };
274
+
275
+ const getRecursiveSections = (
276
+ base: Scope,
277
+ root: ModuleUnit[] | LetExpression,
278
+ hasRecursiveLet = true,
279
+ ) => {
280
+ const sections: RecursiveSection[] = [];
281
+ const pending: Set<string>[] = [];
282
+ const frames: ScopeFrame[] = [];
283
+ const scopes: (Scope | undefined)[] = [];
284
+ let pendingCount = 0;
285
+ let depth = 0;
286
+
287
+ const getScope = () => {
288
+ let start = frames.length;
289
+ while (start > 0 && scopes[start - 1] === undefined) start--;
290
+ let scope = scopes[start - 1] ?? base;
291
+ for (let index = start; index < frames.length; index++) {
292
+ const frame = frames[index];
293
+ scope = Array.isArray(frame)
294
+ ? bindFormals(scope, toFormals(frame))
295
+ : frame.kind === "Let"
296
+ ? createLetScope(frame, scope)
297
+ : frame.kind === "Function"
298
+ ? bindFormals(scope, toFormals(getBoundNames(frame.bounds)))
299
+ : bindFormals(scope, frame.params);
300
+ scopes[index] = scope;
301
+ }
302
+ return scope;
303
+ };
304
+
305
+ const walkInFrame = (frame: ScopeFrame, expression: Expression) => {
306
+ frames.push(frame);
307
+ scopes.push(undefined);
308
+ walkExpression(expression);
309
+ frames.pop();
310
+ scopes.pop();
311
+ };
312
+
313
+ const visitChild = (child: Expression, bound: string[]) =>
314
+ bound.length === 0 ? walkExpression(child) : walkInFrame(bound, child);
315
+
316
+ const walkExpression = (expression: Expression): void => {
317
+ if (expression.kind !== "Let") return forEachChild(expression, visitChild);
318
+ frames.push(expression);
319
+ scopes.push(undefined);
320
+ depth++;
321
+ if (expression.recursive) walkUnits(getLetUnits(expression));
322
+ else {
323
+ for (let index = 0; index < expression.definitions.length; index++) {
324
+ walkDefinition(expression.definitions[index]);
325
+ }
326
+ }
327
+ depth--;
328
+ walkExpression(expression.body);
329
+ frames.pop();
330
+ scopes.pop();
331
+ };
332
+
333
+ const walkDefinition = (definition: Definition) => {
334
+ if (definition.kind === "Function") {
335
+ for (let index = 0; index < definition.bounds.length; index++) {
336
+ walkExpression(definition.bounds[index].set);
337
+ }
338
+ }
339
+ walkInFrame(definition, definition.body);
340
+ if (pendingCount === 0) return;
341
+ const names = (pending[depth] ??= new Set());
342
+ if (definition.isRecursive && names.delete(definition.name)) {
343
+ pendingCount--;
344
+ return;
345
+ }
346
+ sections.at(-1)?.members.push({ definition, scope: getScope(), isRechecked: names.size > 0 });
347
+ };
348
+
349
+ const declareRecursive = (definitions: Definition[], location: SourceLocation) => {
350
+ if (pendingCount === 0) sections.push({ location, members: [] });
351
+ const names = (pending[depth] ??= new Set());
352
+ definitions.forEach((definition) => {
353
+ if (names.has(definition.name)) return;
354
+ names.add(definition.name);
355
+ pendingCount++;
356
+ });
357
+ definitions.forEach((definition) =>
358
+ sections.at(-1)?.members.push({ definition, scope: getScope(), isRechecked: true }),
359
+ );
360
+ };
361
+
362
+ const walkUnits = (units: ModuleUnit[]) => {
363
+ const recursiveDefinitions = new Map<string, Definition[]>();
364
+ units.forEach((unit) => {
365
+ if (unit.kind !== "Definition" || !unit.definition.isRecursive) return;
366
+ const named = recursiveDefinitions.get(unit.definition.name);
367
+ if (named) named.push(unit.definition);
368
+ else recursiveDefinitions.set(unit.definition.name, [unit.definition]);
369
+ });
370
+ units.forEach((unit) => {
371
+ if (unit.kind === "Recursive") {
372
+ declareRecursive(
373
+ unit.declarations.flatMap(
374
+ (declaration) => recursiveDefinitions.get(declaration.name) ?? [],
375
+ ),
376
+ unit.location,
377
+ );
378
+ return;
379
+ }
380
+ if (pendingCount === 0 && !hasRecursiveLet) return;
381
+ if (unit.kind === "Assumption") walkExpression(unit.assumption.expression);
382
+ else if (unit.kind === "Theorem" && unit.theorem.statement.kind !== "AssumeProve") {
383
+ walkExpression(unit.theorem.statement);
384
+ } else if (unit.kind === "Definition") walkDefinition(unit.definition);
385
+ });
386
+ };
387
+
388
+ if (Array.isArray(root)) walkUnits(root);
389
+ else walkExpression(root);
390
+ return sections;
391
+ };
392
+
393
+ const getLetUnits = (expression: LetExpression) =>
394
+ [
395
+ ...(expression.recursive ?? []).map((declaration) => ({
396
+ location: declaration.location,
397
+ unit: {
398
+ kind: "Recursive",
399
+ declarations: [declaration],
400
+ location: declaration.location,
401
+ } satisfies ModuleUnit,
402
+ })),
403
+ ...expression.definitions.map((definition) => ({
404
+ location: definition.location,
405
+ unit: { kind: "Definition", definition } satisfies ModuleUnit,
406
+ })),
407
+ ]
408
+ .toSorted((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
409
+ .map((entry) => entry.unit);
193
410
 
194
411
  const LOGICAL_OPERATORS = new Set(["/\\", "\\/", "=>", "<=>"]);
195
412
 
413
+ const isMixed = (levels: number[]) =>
414
+ levels.includes(ACTION_LEVEL) && levels.includes(TEMPORAL_LEVEL);
415
+
416
+ const getWrittenRange = (expression: Expression) =>
417
+ parenthesizedRanges.get(expression) ?? expression.location.range;
418
+
196
419
  const isOperatorApplication = (expression: Expression) =>
197
420
  expression.kind !== "Let" && expression.kind !== "Label";
198
421
 
199
422
  export const createLevelAnalyzer = (context: LevelContext) => {
200
423
  const definitionLevels = new Map<Definition, OperatorLevels>();
424
+ const selectionLevels = new Map<Expression, LevelData>();
425
+ const errors: SanyError[] = [];
426
+ const messages: string[] = [];
201
427
 
202
428
  const resolve = (name: string, scope: Scope): Resolved => {
203
429
  const entry = scope.get(name);
204
430
  if (entry?.kind === "Formal") {
205
- return { kind: "Declared", name, level: 0, arity: entry.arity };
431
+ return { kind: "Declared", name, level: entry.level, arity: entry.arity };
206
432
  }
207
433
  if (entry?.kind === "Let") {
208
434
  return { kind: "Defined", levels: analyzeDefinition(entry.definition, entry.scope) };
@@ -225,18 +451,15 @@ export const createLevelAnalyzer = (context: LevelContext) => {
225
451
 
226
452
  const applyDeclared = (name: string, level: number, operands: Operand[]) => {
227
453
  const data = createData(Math.max(level, ...operands.map((operand) => operand.data.level)));
454
+ data.isCorrect = operands.every((operand) => operand.data.isCorrect);
228
455
  data.params.add(name);
229
456
  operands.forEach((operand, index) => {
230
457
  operand.data.params.forEach((param) => {
231
458
  data.params.add(param);
232
459
  data.argParams.add(getArgumentParamKey(name, index, param));
233
460
  });
234
- operand.data.constraints.forEach((value, key) => putConstraint(data.constraints, key, value));
235
461
  putArgConstraint(data.argConstraints, getArgumentKey(name, index), operand.data.level);
236
- operand.data.argConstraints.forEach((value, key) =>
237
- putArgConstraint(data.argConstraints, key, value),
238
- );
239
- operand.data.argParams.forEach((key) => data.argParams.add(key));
462
+ mergeConstraints(data, operand.data);
240
463
  });
241
464
  return data;
242
465
  };
@@ -248,19 +471,18 @@ export const createLevelAnalyzer = (context: LevelContext) => {
248
471
  bound: string[] = [],
249
472
  ) => {
250
473
  const isBound = (name: string) => bound.includes(name);
251
- operands.forEach((operand, index) => {
252
- if (operand.operator || operand.declared) return;
253
- if (operand.data.level > getMaxLevel(operator, index)) {
254
- throw new TlaSyntaxError(
255
- `Level error in applying operator ${operator.name}:\nThe level of argument ${index + 1} exceeds the maximum level allowed by the operator`,
256
- );
257
- }
258
- });
259
- if (ranges.some((range) => range.level > ACTION_LEVEL)) {
260
- throw new TlaSyntaxError(
261
- `Level error in applying operator ${operator.name}:\nThe level of the range for a bounded variable exceeds the maximum level allowed by the operator`,
474
+ const exceeding = operands.flatMap((operand, index) =>
475
+ operand.kind === "Value" && operand.data.level > getMaxLevel(operator, index)
476
+ ? [{ operand, index }]
477
+ : [],
478
+ );
479
+ exceeding
480
+ .filter((entry) => operator.isCorrect && entry.operand.data.isCorrect)
481
+ .forEach((entry) =>
482
+ messages.push(
483
+ `Level error in applying operator ${resolveSynonym(operator.name)}:\nThe level of argument ${entry.index + 1} exceeds the maximum level allowed by the operator`,
484
+ ),
262
485
  );
263
- }
264
486
  const getOperand = (formal: string) => {
265
487
  const index = operator.formals.findIndex((param) => param.name === formal);
266
488
  return index === -1 ? undefined : operands[index];
@@ -276,6 +498,10 @@ export const createLevelAnalyzer = (context: LevelContext) => {
276
498
  ...ranges.map((range) => range.level),
277
499
  ),
278
500
  );
501
+ data.isCorrect =
502
+ exceeding.length === 0 &&
503
+ operands.every((operand) => operand.data.isCorrect) &&
504
+ ranges.every((range) => range.isCorrect);
279
505
  operator.params.forEach((param) => data.params.add(param));
280
506
  operands.forEach((operand, index) => {
281
507
  if (getWeight(operator, index) === 1) {
@@ -300,8 +526,8 @@ export const createLevelAnalyzer = (context: LevelContext) => {
300
526
  }),
301
527
  );
302
528
  operands.forEach((operand, operandIndex) => {
303
- const argument = operand.operator;
304
- if (!argument) return;
529
+ if (operand.kind !== "Operator") return;
530
+ const argument = operand.data;
305
531
  operands.forEach((other, otherIndex) =>
306
532
  argument.formals.forEach((_formal, argumentIndex) => {
307
533
  if (!hasCondition(operandIndex, otherIndex, argumentIndex)) return;
@@ -313,9 +539,13 @@ export const createLevelAnalyzer = (context: LevelContext) => {
313
539
  });
314
540
  operator.argParams.forEach((key) => {
315
541
  const parameter = parseArgumentParamKey(key);
316
- const argument = getOperand(parameter.operator)?.operator;
317
- if (argument) {
318
- putConstraint(data.constraints, parameter.param, getMaxLevel(argument, parameter.index));
542
+ const argument = getOperand(parameter.operator);
543
+ if (argument?.kind === "Operator") {
544
+ putConstraint(
545
+ data.constraints,
546
+ parameter.param,
547
+ getMaxLevel(argument.data, parameter.index),
548
+ );
319
549
  }
320
550
  });
321
551
 
@@ -328,8 +558,8 @@ export const createLevelAnalyzer = (context: LevelContext) => {
328
558
  constraints.forEach((value, key) => putArgConstraint(data.argConstraints, key, value)),
329
559
  );
330
560
  operands.forEach((operand, operandIndex) => {
561
+ if (operand.kind !== "Declared") return;
331
562
  const declared = operand.declared;
332
- if (!declared) return;
333
563
  Array.from({ length: declared.arity }, (_value, argumentIndex) =>
334
564
  putArgConstraint(
335
565
  data.argConstraints,
@@ -381,15 +611,15 @@ export const createLevelAnalyzer = (context: LevelContext) => {
381
611
  );
382
612
  return;
383
613
  }
384
- if (argument.declared) {
614
+ if (argument.kind === "Declared") {
385
615
  data.argParams.add(
386
616
  getArgumentParamKey(argument.declared.name, parameter.index, parameter.param),
387
617
  );
388
618
  }
389
619
  });
390
620
  operands.forEach((operand, operandIndex) => {
621
+ if (operand.kind !== "Declared") return;
391
622
  const declared = operand.declared;
392
- if (!declared) return;
393
623
  operands.forEach((other, otherIndex) =>
394
624
  Array.from({ length: declared.arity }, (_value, argumentIndex) => {
395
625
  if (!hasCondition(operandIndex, otherIndex, argumentIndex)) return;
@@ -410,7 +640,7 @@ export const createLevelAnalyzer = (context: LevelContext) => {
410
640
  expression.body,
411
641
  scope,
412
642
  );
413
- return { data: operator, operator };
643
+ return { kind: "Operator", data: operator };
414
644
  }
415
645
  const name =
416
646
  expression.kind === "OperatorReference"
@@ -424,16 +654,16 @@ export const createLevelAnalyzer = (context: LevelContext) => {
424
654
  resolved.kind === "Defined" &&
425
655
  (resolved.levels.formals.length > 0 || expression.kind === "OperatorReference")
426
656
  ) {
427
- return { data: resolved.levels, operator: resolved.levels };
657
+ return { kind: "Operator", data: resolved.levels };
428
658
  }
429
659
  if (resolved.kind === "Declared" && resolved.arity > 0) {
430
660
  const data = createData();
431
661
  data.params.add(name);
432
- return { data, declared: { name, arity: resolved.arity } };
662
+ return { kind: "Declared", data, declared: { name, arity: resolved.arity } };
433
663
  }
434
- if (expression.kind === "OperatorReference") return { data: createData() };
664
+ if (expression.kind === "OperatorReference") return { kind: "Value", data: createData() };
435
665
  }
436
- return { data: analyze(expression, scope) };
666
+ return { kind: "Value", data: analyze(expression, scope) };
437
667
  };
438
668
 
439
669
  const toOperands = (expressions: Expression[], scope: Scope) =>
@@ -443,16 +673,23 @@ export const createLevelAnalyzer = (context: LevelContext) => {
443
673
  operator: OperatorLevels,
444
674
  expressions: Expression[],
445
675
  scope: Scope,
446
- ranges: Expression[] = [],
447
- bound: string[] = [],
676
+ bounds: Bound[] = [],
677
+ bound = getBoundNames(bounds),
448
678
  ) => {
449
- const inner = bindFormals(scope, toFormals(bound));
450
- return applyDefined(
451
- operator,
452
- toOperands(expressions, inner),
453
- ranges.map((range) => analyze(range, scope)),
454
- bound,
455
- );
679
+ const operands = toOperands(expressions, bindFormals(scope, toFormals(bound)));
680
+ const ranges = bounds.map((range) => analyze(range.set, scope));
681
+ const data = applyDefined(operator, operands, ranges, bound);
682
+ ranges.forEach((range, index) => {
683
+ if (range.level <= ACTION_LEVEL) return;
684
+ data.isCorrect = false;
685
+ if (!range.isCorrect) return;
686
+ const pattern = bounds[index].pattern;
687
+ const symbol = pattern.ranges?.[0];
688
+ messages.push(
689
+ `Level error in applying operator ${operator.name}:\nThe level of the range for the bounded variable ${symbol ? formatRange(symbol) : getPatternNames(pattern)[0]} \nexceeds the maximum level allowed by the operator`,
690
+ );
691
+ });
692
+ return data;
456
693
  };
457
694
 
458
695
  const applyResolved = (resolved: Resolved, operands: Operand[]) =>
@@ -460,25 +697,21 @@ export const createLevelAnalyzer = (context: LevelContext) => {
460
697
  ? applyDeclared(resolved.name, resolved.level, operands)
461
698
  : applyDefined(resolved.levels, operands);
462
699
 
463
- const checkJunction = (operands: Operand[], expression: Expression) => {
464
- const levels = operands.map((operand) => operand.data.level);
465
- if (levels.includes(ACTION_LEVEL) && levels.includes(TEMPORAL_LEVEL)) {
466
- throw createLevelError(
467
- "Formula has both temporal formula and action as arguments",
468
- expression,
469
- );
470
- }
700
+ const checkJunction = (levels: number[], name: string) => {
701
+ if (isMixed(levels)) messages.push(`${name} has both temporal formula and action as arguments`);
471
702
  };
472
703
 
473
704
  const checkApply = (expression: Expression & { kind: "Apply" }, operands: Operand[]) => {
474
705
  const isLeadsTo = expression.operator === "~>" || expression.operator === "-+->";
475
706
  if (isLeadsTo && operands.some((operand) => operand.data.level === ACTION_LEVEL)) {
476
- throw createLevelError(
477
- "Action used where only temporal formula or state predicate allowed",
478
- expression,
707
+ messages.push("Action used where only temporal formula or state predicate allowed");
708
+ }
709
+ if (LOGICAL_OPERATORS.has(expression.operator)) {
710
+ checkJunction(
711
+ operands.map((operand) => operand.data.level),
712
+ resolveSynonym(expression.operator),
479
713
  );
480
714
  }
481
- if (LOGICAL_OPERATORS.has(expression.operator)) checkJunction(operands, expression);
482
715
  };
483
716
 
484
717
  const checkTemporal = (
@@ -488,45 +721,56 @@ export const createLevelAnalyzer = (context: LevelContext) => {
488
721
  const operand = expression.expression;
489
722
  const form = expression.kind === "Always" ? "BoxAction" : "AngleAction";
490
723
  if (level !== ACTION_LEVEL || !isOperatorApplication(operand) || operand.kind === form) return;
491
- throw createLevelError(
724
+ messages.push(
492
725
  expression.kind === "Always"
493
726
  ? "[] followed by action not of form [A]_v"
494
727
  : "<> followed by action not of form <<A>>_v",
495
- expression,
496
728
  );
497
729
  };
498
730
 
499
- const analyzeLet = (expression: Expression & { kind: "Let" }, scope: Scope) => {
500
- const inner = new Map(scope);
501
- expression.definitions.forEach((definition) =>
502
- inner.set(definition.name, { kind: "Let", definition, scope: inner }),
731
+ const analyzeLet = (expression: LetExpression, scope: Scope) => {
732
+ const inner = createLetScope(expression, scope);
733
+ if (expression.recursive) {
734
+ getRecursiveSections(scope, expression).forEach((section) =>
735
+ checkRecursiveSection(section.members),
736
+ );
737
+ }
738
+ const definitions = expression.definitions.map((definition) =>
739
+ analyzeDefinition(definition, inner),
503
740
  );
504
741
  const body = analyze(expression.body, inner);
505
742
  const data = {
506
743
  level: body.level,
744
+ isCorrect: body.isCorrect && definitions.every((levels) => levels.isCorrect),
507
745
  params: new Set(body.params),
508
746
  constraints: new Map(body.constraints),
509
747
  argConstraints: new Map(body.argConstraints),
510
748
  argParams: new Set(body.argParams),
511
749
  };
512
- expression.definitions.forEach((definition) => {
513
- const levels = analyzeDefinition(definition, inner);
514
- levels.constraints.forEach((value, key) => putConstraint(data.constraints, key, value));
515
- levels.argConstraints.forEach((value, key) =>
516
- putArgConstraint(data.argConstraints, key, value),
517
- );
518
- levels.argParams.forEach((key) => data.argParams.add(key));
519
- });
750
+ definitions.forEach((levels) => mergeConstraints(data, levels));
520
751
  return data;
521
752
  };
522
753
 
523
- const analyze = (expression: Expression, scope: Scope): LevelData => {
524
- try {
525
- return analyzeNode(expression, scope);
526
- } catch (error) {
527
- if (!(error instanceof TlaSyntaxError) || error.sany) throw error;
528
- throw createLevelError(error.message, expression);
754
+ const reportSince = (start: number, range: SourceRange | undefined, data: LevelData) => {
755
+ if (messages.length === start) return data;
756
+ if (range) {
757
+ messages
758
+ .splice(start)
759
+ .forEach((message) =>
760
+ errors.push({ location: formatRange(range), message: `${message}.` }),
761
+ );
529
762
  }
763
+ return { ...data, isCorrect: false };
764
+ };
765
+
766
+ const reportAt = (range: SourceRange | undefined, getData: () => LevelData) => {
767
+ const start = messages.length;
768
+ return reportSince(start, range, getData());
769
+ };
770
+
771
+ const analyze = (expression: Expression, scope: Scope) => {
772
+ const start = messages.length;
773
+ return reportSince(start, expression.location.range, analyzeNode(expression, scope));
530
774
  };
531
775
 
532
776
  const analyzeNode = (expression: Expression, scope: Scope): LevelData => {
@@ -548,30 +792,65 @@ export const createLevelAnalyzer = (context: LevelContext) => {
548
792
  return toOperand(expression, scope).data;
549
793
  case "And":
550
794
  case "Or": {
551
- const operands = toOperands(expression.operands, scope);
552
- checkJunction(operands, expression);
553
- return applyDefined(JUNCTION_LEVELS, operands);
795
+ const isAnd = expression.kind === "And";
796
+ if (expression.isBulleted) {
797
+ const operands = toOperands(expression.operands, scope);
798
+ checkJunction(
799
+ operands.map((operand) => operand.data.level),
800
+ `${isAnd ? "Conjunction" : "Disjunction"} list`,
801
+ );
802
+ return applyDefined(isAnd ? AND_LEVELS : OR_LEVELS, operands);
803
+ }
804
+ // SANY nests a chain of infix /\ or \/ to the left, so it checks each prefix of the chain.
805
+ const name = isAnd ? "\\land" : "\\lor";
806
+ const start = getWrittenRange(expression.operands[0]);
807
+ const operands: Operand[] = [];
808
+ let prefixLevel = CONSTANT_LEVEL;
809
+ let isPrefixMixed = false;
810
+ expression.operands.forEach((operand, index) => {
811
+ const analyzed = toOperand(operand, scope);
812
+ operands.push(analyzed);
813
+ const levels = [prefixLevel, analyzed.data.level];
814
+ prefixLevel = Math.max(prefixLevel, analyzed.data.level);
815
+ if (index === 0) return;
816
+ const end = getWrittenRange(operand);
817
+ if (index === expression.operands.length - 1 || !start || !end) {
818
+ checkJunction(levels, name);
819
+ return;
820
+ }
821
+ if (!isMixed(levels)) return;
822
+ errors.push({
823
+ location: formatRange({ ...start, end: end.end }),
824
+ message: `${name} has both temporal formula and action as arguments.`,
825
+ });
826
+ isPrefixMixed = true;
827
+ });
828
+ const data = applyDefined(isAnd ? AND_LEVELS : OR_LEVELS, operands);
829
+ return isPrefixMixed ? { ...data, isCorrect: false } : data;
554
830
  }
555
831
  case "Prime":
556
- case "Unchanged":
557
832
  return applyBuiltin(PRIME_LEVELS, [expression.expression], scope);
833
+ case "Unchanged":
834
+ return applyBuiltin(UNCHANGED_LEVELS, [expression.expression], scope);
558
835
  case "Enabled":
559
836
  return applyBuiltin(ENABLED_LEVELS, [expression.expression], scope);
560
837
  case "Always":
561
838
  case "Eventually": {
562
839
  const operand = toOperand(expression.expression, scope);
563
840
  checkTemporal(expression, operand.data.level);
564
- return applyDefined(TEMPORAL_LEVELS, [operand]);
841
+ return applyDefined(expression.kind === "Always" ? ALWAYS_LEVELS : EVENTUALLY_LEVELS, [
842
+ operand,
843
+ ]);
565
844
  }
566
845
  case "If":
567
846
  return applyBuiltin(
568
- JUNCTION_LEVELS,
847
+ IF_LEVELS,
569
848
  [expression.condition, expression.consequent, expression.alternative],
570
849
  scope,
571
850
  );
572
851
  case "Case":
573
852
  return applyBuiltin(
574
- JUNCTION_LEVELS,
853
+ CASE_LEVELS,
575
854
  [
576
855
  ...expression.arms.flatMap((arm) => [arm.condition, arm.body]),
577
856
  ...(expression.other ? [expression.other] : []),
@@ -583,27 +862,33 @@ export const createLevelAnalyzer = (context: LevelContext) => {
583
862
  case "Forall":
584
863
  case "Exists": {
585
864
  const data = applyBuiltin(
586
- JUNCTION_LEVELS,
865
+ expression.kind === "Forall" ? FORALL_LEVELS : EXISTS_LEVELS,
587
866
  [expression.body],
588
867
  scope,
589
- expression.bounds.map((bound) => bound.set),
590
- getBoundNames(expression.bounds),
868
+ expression.bounds,
591
869
  );
592
870
  const actionBound =
593
871
  data.level === TEMPORAL_LEVEL
594
872
  ? expression.bounds.find((bound) => analyze(bound.set, scope).level === ACTION_LEVEL)
595
873
  : undefined;
596
- if (actionBound) {
597
- throw createLevelError(
598
- "Action-level bound of quantified temporal formula",
599
- actionBound.set,
600
- );
874
+ const range = actionBound?.set.location.range;
875
+ if (range) {
876
+ errors.push({
877
+ location: formatRange(range),
878
+ message: "Action-level bound of quantified temporal formula.",
879
+ });
601
880
  }
602
- return data;
881
+ return actionBound ? { ...data, isCorrect: false } : data;
603
882
  }
604
883
  case "UnboundedQuantifier":
605
884
  return applyBuiltin(
606
- expression.isTemporal ? TEMPORAL_QUANTIFIER_LEVELS : JUNCTION_LEVELS,
885
+ expression.isTemporal
886
+ ? expression.quantifier === "Forall"
887
+ ? TEMPORAL_FORALL_LEVELS
888
+ : TEMPORAL_EXISTS_LEVELS
889
+ : expression.quantifier === "Forall"
890
+ ? UNBOUNDED_FORALL_LEVELS
891
+ : UNBOUNDED_EXISTS_LEVELS,
607
892
  [expression.body],
608
893
  scope,
609
894
  [],
@@ -611,95 +896,106 @@ export const createLevelAnalyzer = (context: LevelContext) => {
611
896
  );
612
897
  case "Choose":
613
898
  return applyBuiltin(
614
- CHOOSE_LEVELS,
899
+ expression.set ? BOUNDED_CHOOSE_LEVELS : UNBOUNDED_CHOOSE_LEVELS,
615
900
  [expression.body],
616
901
  scope,
617
- expression.set ? [expression.set] : [],
902
+ expression.set ? [{ pattern: expression.pattern, set: expression.set }] : [],
618
903
  getPatternNames(expression.pattern),
619
904
  );
620
905
  case "SetEnumeration":
906
+ return applyBuiltin(SET_ENUMERATE_LEVELS, expression.elements, scope);
621
907
  case "Tuple":
908
+ return applyBuiltin(TUPLE_LEVELS, expression.elements, scope);
622
909
  case "FunctionSet":
910
+ return applyBuiltin(SET_OF_FCNS_LEVELS, [expression.domain, expression.range], scope);
623
911
  case "Product":
624
- return applyBuiltin(
625
- SET_LEVELS,
626
- expression.kind === "FunctionSet"
627
- ? [expression.domain, expression.range]
628
- : expression.kind === "Product"
629
- ? expression.factors
630
- : expression.elements,
631
- scope,
632
- );
912
+ return applyBuiltin(CARTESIAN_PROD_LEVELS, expression.factors, scope);
633
913
  case "SetFilter":
634
- return applyBuiltin(
635
- SET_LEVELS,
636
- [expression.predicate],
637
- scope,
638
- [expression.bound.set],
639
- getPatternNames(expression.bound.pattern),
640
- );
914
+ return applyBuiltin(SUBSET_OF_LEVELS, [expression.predicate], scope, [expression.bound]);
641
915
  case "SetMap":
642
- return applyBuiltin(
643
- SET_LEVELS,
644
- [expression.expression],
645
- scope,
646
- expression.bounds.map((bound) => bound.set),
647
- getBoundNames(expression.bounds),
648
- );
916
+ return applyBuiltin(SET_OF_ALL_LEVELS, [expression.expression], scope, expression.bounds);
649
917
  case "FunctionConstruction":
650
- return applyBuiltin(
651
- FUNCTION_LEVELS,
652
- [expression.body],
653
- scope,
654
- expression.bounds.map((bound) => bound.set),
655
- getBoundNames(expression.bounds),
656
- );
918
+ return applyBuiltin(FCN_CONSTRUCTOR_LEVELS, [expression.body], scope, expression.bounds);
657
919
  case "Record":
658
920
  return applyBuiltin(
659
- FUNCTION_LEVELS,
921
+ RCD_CONSTRUCTOR_LEVELS,
660
922
  expression.fields.map((field) => field.value),
661
923
  scope,
662
924
  );
663
925
  case "RecordSet":
664
926
  return applyBuiltin(
665
- SET_LEVELS,
927
+ SET_OF_RCDS_LEVELS,
666
928
  expression.fields.map((field) => field.value),
667
929
  scope,
668
930
  );
669
931
  case "Except":
670
- return applyBuiltin(
671
- SET_LEVELS,
672
- [
673
- expression.function,
674
- ...expression.updates.flatMap((update) => [
675
- ...update.path.flatMap((step) => (step.kind === "Index" ? step.args : [])),
676
- update.value,
932
+ return applyDefined(EXCEPT_LEVELS, [
933
+ toOperand(expression.function, scope),
934
+ ...expression.updates.map((update): Operand => ({
935
+ kind: "Value",
936
+ data: applyDefined(PAIR_LEVELS, [
937
+ {
938
+ kind: "Value",
939
+ data: reportAt(update.range, () =>
940
+ applyDefined(
941
+ SEQ_LEVELS,
942
+ update.path.map((step): Operand =>
943
+ step.kind === "Field"
944
+ ? { kind: "Value", data: createData() }
945
+ : step.args.length === 1
946
+ ? toOperand(step.args[0], scope)
947
+ : {
948
+ kind: "Value",
949
+ data: reportAt(step.tupleRange, () =>
950
+ applyBuiltin(TUPLE_LEVELS, step.args, scope),
951
+ ),
952
+ },
953
+ ),
954
+ ),
955
+ ),
956
+ },
957
+ toOperand(update.value, scope),
677
958
  ]),
678
- ],
679
- scope,
680
- );
959
+ })),
960
+ ]);
681
961
  case "FunctionApplication":
682
962
  return applyDefined(APPLY_LEVELS, [
683
963
  toOperand(expression.function, scope),
684
964
  expression.args.length === 1
685
965
  ? toOperand(expression.args[0], scope)
686
- : { data: applyBuiltin(SET_LEVELS, expression.args, scope) },
966
+ : { kind: "Value", data: applyBuiltin(TUPLE_LEVELS, expression.args, scope) },
687
967
  ]);
688
968
  case "Bracket":
689
969
  return createData();
690
970
  case "FieldAccess":
691
971
  return applyDefined(SELECT_LEVELS, [
692
972
  toOperand(expression.record, scope),
693
- { data: createData() },
973
+ { kind: "Value", data: createData() },
694
974
  ]);
695
975
  case "BoxAction":
696
976
  case "AngleAction":
697
- return applyBuiltin(ACTION_LEVELS, [expression.action, expression.subscript], scope);
977
+ return applyBuiltin(
978
+ expression.kind === "BoxAction" ? SQUARE_ACT_LEVELS : ANGLE_ACT_LEVELS,
979
+ [expression.action, expression.subscript],
980
+ scope,
981
+ );
698
982
  case "WeakFairness":
699
983
  case "StrongFairness":
700
- return applyBuiltin(FAIRNESS_LEVELS, [expression.subscript, expression.action], scope);
984
+ return applyBuiltin(
985
+ expression.kind === "WeakFairness" ? WF_LEVELS : SF_LEVELS,
986
+ [expression.subscript, expression.action],
987
+ scope,
988
+ );
701
989
  case "Label":
702
990
  return analyze(expression.body, scope);
991
+ case "Selection": {
992
+ const selected = expression.expression;
993
+ const known = selectionLevels.get(selected);
994
+ if (known) return known;
995
+ const data = analyze(selected, scope);
996
+ selectionLevels.set(selected, data);
997
+ return data;
998
+ }
703
999
  case "Subexpression":
704
1000
  return createData();
705
1001
  }
@@ -733,6 +1029,7 @@ export const createLevelAnalyzer = (context: LevelContext) => {
733
1029
  return names;
734
1030
  case "Lambda":
735
1031
  case "Let":
1032
+ case "Selection":
736
1033
  return names;
737
1034
  case "Prime":
738
1035
  case "Unchanged":
@@ -753,10 +1050,9 @@ export const createLevelAnalyzer = (context: LevelContext) => {
753
1050
  );
754
1051
  return names;
755
1052
  default:
756
- mapChildren(expression, (child, bound) => {
757
- visit(child, isNonLeibniz, bindFormals(scope, toFormals(bound)));
758
- return child;
759
- });
1053
+ forEachChild(expression, (child, bound) =>
1054
+ visit(child, isNonLeibniz, bindFormals(scope, toFormals(bound))),
1055
+ );
760
1056
  return names;
761
1057
  }
762
1058
  };
@@ -770,9 +1066,13 @@ export const createLevelAnalyzer = (context: LevelContext) => {
770
1066
  const inner = bindFormals(scope, formals);
771
1067
  const data = analyze(body, inner);
772
1068
  const isFormal = (param: string) => formals.some((formal) => formal.name === param);
773
- const nonLeibnizNames = getNonLeibnizNames(body, inner);
1069
+ const nonLeibnizNames = getNonLeibnizNames(
1070
+ body.kind === "Selection" ? body.expression : body,
1071
+ inner,
1072
+ );
774
1073
  const levels: OperatorLevels = {
775
1074
  ...createData(data.level),
1075
+ isCorrect: data.isCorrect,
776
1076
  name,
777
1077
  formals,
778
1078
  nonLeibniz: new Set(
@@ -816,35 +1116,87 @@ export const createLevelAnalyzer = (context: LevelContext) => {
816
1116
  return levels;
817
1117
  };
818
1118
 
1119
+ const staleDefinitions = new Set<Definition>();
1120
+
819
1121
  const analyzeDefinition = (definition: Definition, scope: Scope): OperatorLevels => {
820
1122
  const cached = definitionLevels.get(definition);
821
- if (cached) return cached;
822
- const formals = definition.kind === "Operator" ? definition.params : [];
823
- definitionLevels.set(definition, {
824
- ...createData(),
825
- name: definition.name,
826
- formals,
827
- maxLevels: formals.map(() => TEMPORAL_LEVEL),
828
- weights: formals.map(() => 0),
829
- minMaxLevels: formals.map(() => []),
830
- conditions: new Set(),
831
- nonLeibniz: new Set(),
1123
+ if (cached && !staleDefinitions.delete(definition)) return cached;
1124
+ const prior = cached ?? createPlaceholder(definition, TEMPORAL_LEVEL, 0);
1125
+ definitionLevels.set(definition, prior);
1126
+ const levels = analyzeOperator(
1127
+ definition.name,
1128
+ getFormals(definition),
1129
+ getDefinitionBody(definition),
1130
+ scope,
1131
+ );
1132
+ const merged = {
1133
+ ...levels,
1134
+ level: Math.max(prior.level, levels.level),
1135
+ params: new Set([...prior.params, ...levels.params]),
1136
+ argParams: new Set([...prior.argParams, ...levels.argParams]),
1137
+ maxLevels: levels.maxLevels.map((level, index) => Math.min(level, prior.maxLevels[index])),
1138
+ weights: levels.weights.map((weight, index) => Math.max(weight, prior.weights[index])),
1139
+ nonLeibniz: new Set([...prior.nonLeibniz, ...levels.nonLeibniz]),
1140
+ };
1141
+ definitionLevels.set(definition, merged);
1142
+ return merged;
1143
+ };
1144
+
1145
+ const checkPrimedArguments = (members: SectionMember[]) =>
1146
+ members.forEach((member) => {
1147
+ const range = member.definition.location.range;
1148
+ if (!member.definition.isRecursive || !range) return;
1149
+ analyzeDefinition(member.definition, member.scope).maxLevels.forEach((level, index) => {
1150
+ if (level >= ACTION_LEVEL) return;
1151
+ errors.push({
1152
+ location: formatRange(range),
1153
+ message: `Argument ${index + 1} of recursive operator ${resolveSynonym(member.definition.name)} is primed`,
1154
+ });
1155
+ });
832
1156
  });
833
- const body: Expression =
834
- definition.kind === "Function"
835
- ? {
836
- kind: "FunctionConstruction",
837
- bounds: definition.bounds,
838
- body: definition.body,
839
- location: definition.location,
840
- }
841
- : definition.body;
842
- const levels = analyzeOperator(definition.name, formals, body, scope);
843
- definitionLevels.set(definition, levels);
844
- return levels;
1157
+
1158
+ const checkRecursiveSection = (members: SectionMember[]) => {
1159
+ if (members.length === 0 || definitionLevels.has(members[0].definition)) return;
1160
+ const recursive = members.filter((member) => member.definition.isRecursive);
1161
+ recursive.forEach((member) =>
1162
+ definitionLevels.set(
1163
+ member.definition,
1164
+ createPlaceholder(member.definition, ACTION_LEVEL, 1),
1165
+ ),
1166
+ );
1167
+ const recheck = (member: SectionMember) => {
1168
+ if (member.definition.isRecursive) staleDefinitions.add(member.definition);
1169
+ return analyzeDefinition(member.definition, member.scope);
1170
+ };
1171
+ members.forEach((member) => {
1172
+ recheck(member);
1173
+ checkPrimedArguments([member]);
1174
+ });
1175
+ const firstPass = recursive.map((member) => analyzeDefinition(member.definition, member.scope));
1176
+ const level = Math.max(CONSTANT_LEVEL, ...firstPass.map((levels) => levels.level));
1177
+ const params = firstPass.flatMap((levels) => [...levels.params]);
1178
+ members.forEach((member) => {
1179
+ const levels = analyzeDefinition(member.definition, member.scope);
1180
+ definitionLevels.set(member.definition, {
1181
+ ...levels,
1182
+ level: Math.max(levels.level, level),
1183
+ params: new Set([...levels.params, ...params]),
1184
+ });
1185
+ if (member.isRechecked && !member.definition.isRecursive) {
1186
+ staleDefinitions.add(member.definition);
1187
+ }
1188
+ });
1189
+ members.forEach(recheck);
845
1190
  };
846
1191
 
847
- return { analyze, analyzeDefinition, toOperand };
1192
+ return {
1193
+ analyze,
1194
+ analyzeDefinition,
1195
+ checkPrimedArguments,
1196
+ checkRecursiveSection,
1197
+ toOperand,
1198
+ errors,
1199
+ };
848
1200
  };
849
1201
 
850
1202
  export const analyzeAssumeProve = (
@@ -856,7 +1208,18 @@ export const analyzeAssumeProve = (
856
1208
  const parts = assumeProve.assumptions.flatMap((assumption) => {
857
1209
  if (assumption.kind === "NewSymbol") {
858
1210
  const set = assumption.set && analyzer.analyze(assumption.set, inner);
859
- inner.set(assumption.name, { kind: "Formal", arity: assumption.arity });
1211
+ const range = assumption.location.range;
1212
+ if (set?.level === TEMPORAL_LEVEL && range) {
1213
+ analyzer.errors.push({
1214
+ location: formatRange(range),
1215
+ message: "Level error:\nTemporal formula used as set.",
1216
+ });
1217
+ }
1218
+ inner.set(assumption.name, {
1219
+ kind: "Formal",
1220
+ arity: assumption.arity,
1221
+ level: NEW_SYMBOL_LEVELS[assumption.level],
1222
+ });
860
1223
  return set ? [set] : [];
861
1224
  }
862
1225
  return [
@@ -869,9 +1232,7 @@ export const analyzeAssumeProve = (
869
1232
  const data = createData(Math.max(...parts.map((part) => part.level)));
870
1233
  parts.forEach((part) => {
871
1234
  part.params.forEach((param) => data.params.add(param));
872
- part.constraints.forEach((value, key) => putConstraint(data.constraints, key, value));
873
- part.argConstraints.forEach((value, key) => putArgConstraint(data.argConstraints, key, value));
874
- part.argParams.forEach((key) => data.argParams.add(key));
1235
+ mergeConstraints(data, part);
875
1236
  });
876
1237
  return data;
877
1238
  };
@@ -883,27 +1244,35 @@ export const checkModuleLevels = (
883
1244
  warnings: SanyError[],
884
1245
  ) => {
885
1246
  const analyzer = createLevelAnalyzer(context);
886
- const getLevel = (expressions: Expression[]) =>
887
- Math.max(0, ...expressions.map((expression) => analyzer.analyze(expression, new Map()).level));
888
- const getStepLevel = (step: ProofStep) => {
1247
+ const getLevel = (expressions: Expression[], scope: Scope) =>
1248
+ Math.max(0, ...expressions.map((expression) => analyzer.analyze(expression, scope).level));
1249
+ const getStepLevel = (step: ProofStep, scope: Scope) => {
889
1250
  const body = step.body;
890
- if (body.kind === "Have" || body.kind === "Case") return getLevel([body.expression]);
891
- if (body.kind === "Witness") return getLevel(body.expressions);
892
- if (body.kind === "Take") return getLevel(body.bounds.map((bound) => bound.set));
1251
+ if (body.kind === "Have" || body.kind === "Case") return getLevel([body.expression], scope);
1252
+ if (body.kind === "Witness") return getLevel(body.expressions, scope);
1253
+ if (body.kind === "Take")
1254
+ return getLevel(
1255
+ body.bounds.map((bound) => bound.set),
1256
+ scope,
1257
+ );
893
1258
  if (body.kind === "Pick") {
894
- return getLevel([body.body, ...body.bounds.map((bound) => bound.set)]);
1259
+ return getLevel([body.body, ...body.bounds.map((bound) => bound.set)], scope);
895
1260
  }
896
1261
  if (body.kind !== "Assert") return 0;
897
1262
  return body.statement.kind === "AssumeProve"
898
- ? analyzeAssumeProve(body.statement, new Map(), analyzer).level
899
- : getLevel([body.statement]);
1263
+ ? analyzeAssumeProve(body.statement, scope, analyzer).level
1264
+ : getLevel([body.statement], scope);
900
1265
  };
1266
+ const checkFacts = (facts: Fact[], scope: Scope) =>
1267
+ facts.forEach((fact) => {
1268
+ if (fact.kind !== "ModuleFact") analyzer.analyze(fact, scope);
1269
+ });
901
1270
  const checkTemporalGoal = (proof: Proof | undefined): SanyError[] =>
902
1271
  proof?.kind !== "Steps"
903
1272
  ? []
904
1273
  : proof.steps.flatMap((step) => {
905
1274
  const location = formatRange(step.statement);
906
- const isConstant = () => getStepLevel(step) === 0;
1275
+ const isConstant = () => getStepLevel(step, new Map()) === 0;
907
1276
  if (
908
1277
  step.body.kind === "Have" ||
909
1278
  step.body.kind === "Take" ||
@@ -923,62 +1292,129 @@ export const checkModuleLevels = (
923
1292
  }
924
1293
  return step.body.kind === "Qed" ? checkTemporalGoal(step.proof) : [];
925
1294
  });
926
- const checkProof = (proof: Proof | undefined): SanyError[] =>
927
- proof?.kind !== "Steps"
928
- ? []
929
- : proof.steps.flatMap((step) => {
930
- const body = step.body;
931
- const isTemporal = () => getStepLevel(step) === TEMPORAL_LEVEL;
932
- const pickErrors =
933
- body.kind === "Pick" && body.bounds.length > 0 && isTemporal()
934
- ? body.bounds
935
- .filter((bound) => getLevel([bound.set]) !== 0)
936
- .flatMap((bound) =>
937
- bound.set.location.range
938
- ? [
939
- {
940
- location: formatRange(bound.set.location.range),
941
- message: "Non-constant bound of temporal PICK.",
942
- },
943
- ]
944
- : [],
945
- )
946
- : [];
947
- return [
948
- ...checkProof(step.proof),
949
- ...pickErrors,
950
- ...(step.proof?.kind === "Steps" && isTemporal() ? checkTemporalGoal(step.proof) : []),
951
- ];
1295
+ const checkProof = (proof: Proof | undefined, scope: Scope): SanyError[] => {
1296
+ if (proof?.kind === "By") {
1297
+ checkFacts(proof.facts, scope);
1298
+ return analyzer.errors.splice(0);
1299
+ }
1300
+ if (proof?.kind !== "Steps") return [];
1301
+ const inner = new Map(scope);
1302
+ return proof.steps.flatMap((step) => {
1303
+ const body = step.body;
1304
+ if (body.kind === "Use" || body.kind === "Hide") checkFacts(body.facts, inner);
1305
+ if (body.kind === "Define") {
1306
+ body.definitions.forEach((definition) => {
1307
+ if (definition.kind === "Instance") return;
1308
+ inner.set(definition.name, { kind: "Let", definition, scope: inner });
1309
+ analyzer.analyzeDefinition(definition, inner);
952
1310
  });
953
- const errors = collectSemanticErrors(
954
- [
955
- ...module.definitions
956
- .filter((definition) => !definition.name.includes("!"))
957
- .map((definition) => ({
958
- location: definition.location,
959
- check: () => analyzer.analyzeDefinition(definition, new Map()),
960
- })),
961
- ...module.assumptions.map((assumption) => ({
962
- location: assumption.location,
963
- check: () => analyzer.analyze(assumption.expression, new Map()),
964
- })),
965
- ...module.theorems.map((theorem) => ({
966
- location: theorem.location,
967
- check: () => {
968
- const data =
969
- theorem.statement.kind === "AssumeProve"
970
- ? analyzeAssumeProve(theorem.statement, new Map(), analyzer)
971
- : analyzer.analyze(theorem.statement, new Map());
972
- const errors = [
973
- ...checkProof(theorem.proof),
974
- ...(data.level === TEMPORAL_LEVEL ? checkTemporalGoal(theorem.proof) : []),
975
- ];
976
- if (errors.length > 0) throw createSanyError(errors);
977
- },
978
- })),
979
- ...instances,
980
- ],
981
- warnings,
982
- );
983
- if (errors.length > 0) throw createSanyError(errors, false, undefined, warnings);
1311
+ }
1312
+ const isTemporal = getStepLevel(step, inner) === TEMPORAL_LEVEL;
1313
+ const pickErrors =
1314
+ body.kind === "Pick" && body.bounds.length > 0 && isTemporal
1315
+ ? body.bounds
1316
+ .filter((bound) => getLevel([bound.set], inner) !== 0)
1317
+ .flatMap((bound) =>
1318
+ bound.set.location.range
1319
+ ? [
1320
+ {
1321
+ location: formatRange(bound.set.location.range),
1322
+ message: "Non-constant bound of temporal PICK.",
1323
+ },
1324
+ ]
1325
+ : [],
1326
+ )
1327
+ : [];
1328
+ return [
1329
+ ...analyzer.errors.splice(0),
1330
+ ...checkProof(step.proof, inner),
1331
+ ...pickErrors,
1332
+ ...(step.proof?.kind === "Steps" && isTemporal ? checkTemporalGoal(step.proof) : []),
1333
+ ];
1334
+ });
1335
+ };
1336
+ const statementLevels = new Map<Expression | AssumeProve, number>();
1337
+ const getStatementLevel = (statement: Expression | AssumeProve) => {
1338
+ const cached = statementLevels.get(statement);
1339
+ if (cached !== undefined) return cached;
1340
+ const level =
1341
+ statement.kind === "AssumeProve"
1342
+ ? analyzeAssumeProve(statement, new Map(), analyzer).level
1343
+ : analyzer.analyze(statement, new Map()).level;
1344
+ statementLevels.set(statement, level);
1345
+ return level;
1346
+ };
1347
+ const statements = [
1348
+ ...module.theorems,
1349
+ ...module.assumptions.map((assumption) => ({
1350
+ ...assumption,
1351
+ statement: assumption.expression,
1352
+ })),
1353
+ ];
1354
+ const statementBodies = new Set(statements.map((statement) => statement.statement));
1355
+ const sections = getRecursiveSections(new Map(), module.units, module.hasRecursiveLet);
1356
+ const createCheck = (location: SourceLocation, run: () => void) => ({
1357
+ location,
1358
+ check: (reported: SanyError[]) => {
1359
+ run();
1360
+ reported.push(...analyzer.errors.splice(0));
1361
+ },
1362
+ });
1363
+ return {
1364
+ sections: sections.map((section) =>
1365
+ createCheck(section.location, () => analyzer.checkRecursiveSection(section.members)),
1366
+ ),
1367
+ check: (isInner: boolean) =>
1368
+ [
1369
+ (isInner ? sections : []).map((section) =>
1370
+ createCheck(section.location, () => analyzer.checkPrimedArguments(section.members)),
1371
+ ),
1372
+ module.definitions
1373
+ .filter(
1374
+ (definition) => !definition.name.includes("!") && !statementBodies.has(definition.body),
1375
+ )
1376
+ .map((definition) =>
1377
+ createCheck(definition.location, () =>
1378
+ analyzer.analyzeDefinition(definition, new Map()),
1379
+ ),
1380
+ ),
1381
+ statements
1382
+ .filter((statement) => statement.name !== undefined)
1383
+ .map((statement) =>
1384
+ createCheck(statement.location, () => getStatementLevel(statement.statement)),
1385
+ ),
1386
+ [
1387
+ ...module.assumptions.map((assumption) => ({
1388
+ location: assumption.location,
1389
+ check: (reported: SanyError[]) => {
1390
+ const level = getStatementLevel(assumption.expression);
1391
+ reported.push(...analyzer.errors.splice(0));
1392
+ const range = assumption.location.range;
1393
+ if (level !== CONSTANT_LEVEL && range) {
1394
+ reported.push({
1395
+ location: formatRange(range),
1396
+ message: `Level error: assumptions must be level 0 (Constant), \nbut this one has level ${level}.`,
1397
+ });
1398
+ }
1399
+ },
1400
+ })),
1401
+ ...module.theorems.map((theorem) => ({
1402
+ location: theorem.location,
1403
+ check: (reported: SanyError[]) => {
1404
+ const level = getStatementLevel(theorem.statement);
1405
+ reported.push(
1406
+ ...analyzer.errors.splice(0),
1407
+ ...checkProof(theorem.proof, new Map()),
1408
+ ...(level === TEMPORAL_LEVEL ? checkTemporalGoal(theorem.proof) : []),
1409
+ ...analyzer.errors.splice(0),
1410
+ );
1411
+ },
1412
+ })),
1413
+ ...module.uses.map((use) =>
1414
+ createCheck(use.location, () => checkFacts(use.facts, new Map())),
1415
+ ),
1416
+ ...instances,
1417
+ ],
1418
+ ].flatMap((units) => collectSemanticErrors(units, warnings)),
1419
+ };
984
1420
  };